コード例 #1
0
ファイル: bounce.c プロジェクト: BackupTheBerlios/uuu
static void draw_ball(void)
{
    GLfloat a, b;
    GLfloat da = 18.0, db = 18.0;
    GLfloat radius = 1.0;
    GLuint color;
    GLfloat x, y, z;

    color = 0;
    for (a = -90.0; a+da <= 90.0; a += da) {
        glBegin(GL_QUAD_STRIP);
        for (b = 0.0; b <=360.0 ; b += db) {
            if (color) 
                glIndexf(4);
            else
                glIndexf(15);
            x = COS(b) * COS(a);
            y = SIN(b) * COS(a);
            z = SIN(a);
            glVertex3f(x, y, z);
            x = radius * COS(b) * COS(a+da);
            y = radius * SIN(b) * COS(a+da);
            z = radius * SIN(a+da);
            glVertex3f(x, y, z);
            color = 1 - color;
            }
        glEnd();
        }
}
コード例 #2
0
ファイル: overlay.c プロジェクト: MttDs/new-rexeno-tindpe
static void Idle(void)
{

    if (overlayInit == GL_FALSE) {
	glutUseLayer(GLUT_OVERLAY);
	glClear(GL_COLOR_BUFFER_BIT);
/*	    glColor3f(1.0, 0.0, 0.0);*/

	glIndexf( 2.0 );
	glBegin(GL_POLYGON);
	    glVertex2i(windW/4-10, windH/4-10);
	    glVertex2i(windW/2-10, windH/4-10);
	    glVertex2i(windW/2-10, windH/2-10);
	    glVertex2i(windW/4-10, windH/2-10);
	glEnd();

        glIndexf( 0.0 );
	glBegin(GL_POLYGON);
	    glVertex2i(windW/4, windH/4);
	    glVertex2i(windW/2, windH/4);
	    glVertex2i(windW/2, windH/2);
	    glVertex2i(windW/4, windH/2);
	glEnd();

        glIndexf( 1.0 );
	glBegin(GL_POLYGON);
	    glVertex2i(windW/4+10, windH/4+10);
	    glVertex2i(windW/2+10, windH/4+10);
	    glVertex2i(windW/2+10, windH/2+10);
	    glVertex2i(windW/4+10, windH/2+10);
	glEnd();

	glutUseLayer(GLUT_NORMAL);
	overlayInit = GL_TRUE;
    }

    MoveStars();
    ShowStars();
    if (nitro > 0) {
	speed = (float)(nitro / 10) + 1.0;
	if (speed > MAXWARP) {
	    speed = MAXWARP;
	}
	if (++nitro > MAXWARP*10) {
	    nitro = -nitro;
	}
    } else if (nitro < 0) {
	nitro++;
	speed = (float)(-nitro / 10) + 1.0;
	if (speed > MAXWARP) {
	    speed = MAXWARP;
	}
    }

    glFlush();
    if (doubleBuffer) {
	glutSwapBuffers();
    }
}
コード例 #3
0
ファイル: test17.c プロジェクト: AlexGreulich/HRTFVR
static void
move_on(void)
{
  display_count++;
  if (display_count == 2) {
    damage_expectation = 1;
    glutIconifyWindow();
    glutTimerFunc(500, timer, 777);
  }
  if (display_count == 4) {
    printf("display_count == 4\n");
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutCreateSubWindow(main_win, 10, 10, 150, 150);
    glClearColor(0.5, 0.5, 0.5, 0.0);
    glutDisplayFunc(render_sub);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
    glutEstablishOverlay();
    glutCopyColormap(main_win);
    glutSetColor((transP + 1) % 2, 0.0, 1.0, 1.0);
    glutRemoveOverlay();
    glutEstablishOverlay();
    glutCopyColormap(main_win);
    glutCopyColormap(main_win);
    glutSetColor((transP + 1) % 2, 1.0, 1.0, 1.0);
    glClearIndex(transP);
    glIndexf((transP + 1) % 2);
    glutSetWindow(main_win);
    glutRemoveOverlay();
    glutTimerFunc(500, time2, 888);
  }
}
コード例 #4
0
ファイル: tkmap.c プロジェクト: tkicks/G5
static void SetColor(int c)
{
    if (glutGet(GLUT_WINDOW_RGBA))
        glColor3fv(RGBMap[c]);
    else
        glIndexf(c);
}
コード例 #5
0
ファイル: cg200.c プロジェクト: jasongi/teapot
/*
 =======================================================================================================================
    sets the color of the next object to draw
 =======================================================================================================================
 */
setColor(int c)
{
	glColor4fv(&materialColor[c][0]);
	if(useLighting)
	{
		{
			if(useRGB)
			{
				glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, &materialColor[c][0]);
			}
			else
			{
				glMaterialfv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, &materialColor[c][0]);
			}
		}
	}
	else
	{
		if(useRGB)
		{
			glColor4fv(&materialColor[c][0]);
		}
		else
		{
			glIndexf(materialColor[c][1]);
		}
	}
}
コード例 #6
0
ファイル: glxspheres.c プロジェクト: stroyan/vogl
void setspherecolor(float c)
{
    if (useci)
    {
        GLfloat ndx = c * (float)(ncolors - 1);
        GLfloat mat_ndxs[] = { ndx * 0.3f, ndx * 0.8f, ndx };
        glIndexf(ndx);
        glMaterialfv(GL_FRONT, GL_COLOR_INDEXES, mat_ndxs);
    }
    else
    {
        float mat[4] = { spherered(c), spheregreen(c), sphereblue(c), 0.25f };
        glColor3f(spherered(c), spheregreen(c), sphereblue(c));
        glMaterialfv(GL_FRONT, GL_AMBIENT, mat);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, mat);
    }
}
コード例 #7
0
ファイル: bounce.c プロジェクト: BackupTheBerlios/uuu
static void draw(void)
{
    GLint i;

    glClear(GL_COLOR_BUFFER_BIT);
    glIndexf(3);
    glBegin(GL_LINES);
    for (i = -5; i <= 5; i++) { 
        glVertex2i(i, -5);   
        glVertex2i(i, 5);
        }
    for (i = -5; i <= 5; i++) { 
        glVertex2i(-5,i);   
        glVertex2i(5,i);
        }
    for (i = -5; i <= 5; i++) { 
        glVertex2i(i, -5);  
        glVertex2f(i*1.15, -5.9);
        }
    glVertex2f(-5.3, -5.35);    
    glVertex2f(5.3, -5.35);
    glVertex2f(-5.75, -5.9);     
    glVertex2f(5.75, -5.9);
    glEnd();
    glFlush();

    glPushMatrix();
    glTranslatef(Xpos, Ypos, 0.0);
    glScalef(2.0, 2.0, 2.0);
    glRotatef(8.0, 0.0, 0.0, 1.0);
    glRotatef(90.0, 1.0, 0.0, 0.0);
    glRotatef(Zrot, 0.0, 0.0, 1.0);
    glCallList(Ball);
    glPopMatrix();
    
    glFlush();
}
コード例 #8
0
ファイル: wave.c プロジェクト: Distrotech/mesa-demos
static void Animate(void)
{
    struct coord *coord;
    struct facet *facet;
    float *lastColor;
    float *thisColor;
    GLint i, j;

    glClear(clearMask);

    if (nextFrame || !stepMode) {
	curFrame++;
    }
    if (curFrame >= theMesh.frames) {
	curFrame = 0;
    }

    if ((nextFrame || !stepMode) && spinMode) {
	glRotatef(5.0, 0.0, 0.0, 1.0);
    }
    nextFrame = 0;

    for (i = 0; i < theMesh.widthX; i++) {
	glBegin(GL_QUAD_STRIP);
	lastColor = NULL;
	for (j = 0; j < theMesh.widthY; j++) {
	    facet = GETFACET(curFrame, i, j);
	    if (!smooth && lighting) {
		glNormal3fv(facet->normal);
	    }
	    if (lighting) {
		if (rgb) {
		    thisColor = facet->color;
		    glColor3fv(facet->color);
		} else {
		    thisColor = facet->color;
		    glMaterialfv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES,
				 facet->color);
		}
	    } else {
		if (rgb) {
		    thisColor = facet->color;
		    glColor3fv(facet->color);
		} else {
		    thisColor = facet->color;
		    glIndexf(facet->color[1]);
		}
	    }

	    if (!lastColor || (thisColor[0] != lastColor[0] && smooth)) {
		if (lastColor) {
		    glEnd();
		    glBegin(GL_QUAD_STRIP);
		}
		coord = GETCOORD(curFrame, i, j);
		if (smooth && lighting) {
		    glNormal3fv(coord->normal);
		}
		glVertex3fv(coord->vertex);

		coord = GETCOORD(curFrame, i+1, j);
		if (smooth && lighting) {
		    glNormal3fv(coord->normal);
		}
		glVertex3fv(coord->vertex);
	    }

	    coord = GETCOORD(curFrame, i, j+1);
	    if (smooth && lighting) {
		glNormal3fv(coord->normal);
	    }
	    glVertex3fv(coord->vertex);

	    coord = GETCOORD(curFrame, i+1, j+1);
	    if (smooth && lighting) {
		glNormal3fv(coord->normal);
	    }
	    glVertex3fv(coord->vertex);

	    lastColor = thisColor;
	}
	glEnd();
    }

    glFlush();
    if (doubleBuffer) {
	glutSwapBuffers();
    }
}
コード例 #9
0
ファイル: GEMglIndexf.cpp プロジェクト: avilleret/Gem
/////////////////////////////////////////////////////////
// Render
//
void GEMglIndexf :: render(GemState *state) {
	glIndexf (c);
}
コード例 #10
0
ファイル: glxspheres.c プロジェクト: stroyan/vogl
int display(SDL_Window *window, int advance)
{
    static int first = 1;
    static double start = 0., elapsed = 0., mpixels = 0.;
    static unsigned long frames = 0;
    static char temps[256];
    GLfloat xaspect, yaspect;

    if (first)
    {
        buildfont();

        GLfloat id4[] = { 1., 1., 1., 1. };
        GLfloat light0_amb[] = { 0.3f, 0.3f, 0.3f, 1.0f };
        GLfloat light0_dif[] = { 0.8f, 0.8f, 0.8f, 1.0f };
        GLfloat light0_pos[] = { 1., 1., 1., 0. };

        spherelist = glGenLists(1);
        if (!(spherequad = gluNewQuadric()))
            _throw("Could not allocate GLU quadric object");
        glNewList(spherelist, GL_COMPILE);
        gluSphere(spherequad, 1.3, slices, stacks);
        glEndList();

        if (!locolor)
        {
            if (useci)
            {
                glMaterialf(GL_FRONT, GL_SHININESS, 50.);
            }
            else
            {
                glMaterialfv(GL_FRONT, GL_AMBIENT, id4);
                glMaterialfv(GL_FRONT, GL_DIFFUSE, id4);
                glMaterialfv(GL_FRONT, GL_SPECULAR, id4);
                glMaterialf(GL_FRONT, GL_SHININESS, 50.);

                glLightfv(GL_LIGHT0, GL_AMBIENT, light0_amb);
                glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_dif);
                glLightfv(GL_LIGHT0, GL_SPECULAR, id4);
            }
            glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
            glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 180.);
            glEnable(GL_LIGHTING);
            glEnable(GL_LIGHT0);
        }

        if (locolor)
            glShadeModel(GL_FLAT);
        else
            glShadeModel(GL_SMOOTH);
        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LESS);

        SDL_snprintf(temps, 255, "Measuring performance ...");

        first = 0;
    }

    if (advance)
    {
        z -= 0.5;
        if (z < -29.)
        {
            if (useci)
            {
                colorscheme = (colorscheme + 1) % NSCHEMES;
                _catch(setcolorscheme(window, ncolors, colorscheme));
            }

            z = -3.5;
        }

        outer_angle += 0.1f;
        if (outer_angle > 360.0f)
            outer_angle -= 360.0f;
        middle_angle -= 0.37f;
        if (middle_angle < -360.0f)
            middle_angle += 360.0f;
        inner_angle += 0.63f;
        if (inner_angle > 360.0f)
            inner_angle -= 360.0f;
        lonesphere_color += 0.005f;
        if (lonesphere_color > 1.0f)
            lonesphere_color -= 1.0f;
    }

    if (usestereo)
    {
        renderspheres(GL_BACK_LEFT);
        renderspheres(GL_BACK_RIGHT);
    }
    else
    {
        renderspheres(GL_BACK);
    }

    glDrawBuffer(GL_BACK);
    glPushAttrib(GL_CURRENT_BIT);
    glPushAttrib(GL_LIST_BIT);
    glPushAttrib(GL_ENABLE_BIT);
    glDisable(GL_LIGHTING);

    if (useci)
        glIndexf(254.);
    else
        glColor3f(1., 1., 1.);

    xaspect = (GLfloat)width / (GLfloat)(min(width, height));
    yaspect = (GLfloat)height / (GLfloat)(min(width, height));
    glRasterPos3f(-0.95f * xaspect, -0.95f * yaspect, -1.5f);

    glListBase(fontlistbase);
    glCallLists((GLsizei)strlen(temps), GL_UNSIGNED_BYTE, temps);
    glPopAttrib();
    glPopAttrib();
    glPopAttrib();

    SDL_GL_SwapWindow(window);

    if (start > 0.)
    {
        elapsed += rrtime() - start;
        frames++;
        totalframes++;
        mpixels += (double)width * (double)height / 1000000.;
        if (elapsed > benchtime || (maxframes && totalframes > maxframes))
        {
            SDL_snprintf(temps, 255, "%f frames/sec - %f Mpixels/sec",
                     (double)frames / elapsed, mpixels / elapsed);
            printf("%s\n", temps);
            elapsed = mpixels = 0.;
            frames = 0;
        }
    }
    if (maxframes && totalframes > maxframes)
        goto bailout;

    start = rrtime();

    return 0;

bailout:
    if (spherequad)
    {
        gluDeleteQuadric(spherequad);
        spherequad = NULL;
    }
    return -1;
}
コード例 #11
0
ファイル: OpenGLWrapper.hpp プロジェクト: Kubeu/trunk
template< > inline void glIndex< float >			( float c )				{	glIndexf(c);	};
コード例 #12
0
ファイル: gl.c プロジェクト: GizmoTheGreen/glshim
void glIndexfv(const GLfloat *c) {
    glIndexf(*c);
}
コード例 #13
0
ファイル: gl.cpp プロジェクト: dschaefer/swt-opengl
M(void, glIndexf, jfloat c) {
	glIndexf(c);
}