void SceneObject::setupMaterials() { glDisable( GL_TEXTURE_2D ); //glColor3f( dbgColor[0], dbgColor[1], dbgColor[2] ); glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, dbgDiffColor ); }
void renderObjects(void) { //Rendu des axes glDisable(GL_LIGHTING); glBegin(GL_LINES); glColor3d(1, 0, 0); glVertex3d(0, 0, 0); glVertex3d(10000, 0, 0); glColor3d(0, 1, 0); glVertex3d(0, 0, 0); glVertex3d(0, 10000, 0); glColor3d(0, 0, 1); glVertex3d(0, 0, 0); glVertex3d(0, 0, 10000); glEnd(); glEnable(GL_LIGHTING); glShadeModel(GL_SMOOTH); glPushMatrix(); //Position du soleil glTranslatef(g_renderer->_Camera->_Position.X, g_renderer->_Camera->_Position.Y, g_renderer->_Camera->_Position.Z); glTranslatef(g_sun_dir.X * 1000, g_sun_dir.Y * 1000, g_sun_dir.Z * 1000); //Material du soleil : de l'emissive GLfloat sunEmissionMaterial[] = { 0.0, 0.0, 0.0,1.0 }; sunEmissionMaterial[0] = g_sun_color.R; sunEmissionMaterial[1] = g_sun_color.V; sunEmissionMaterial[2] = g_sun_color.B; glMaterialfv(GL_FRONT, GL_EMISSION, sunEmissionMaterial); //On dessine un cube pour le soleil glutSolidCube(50.0f); //On reset le material emissive pour la suite sunEmissionMaterial[0] = 0.0f; sunEmissionMaterial[1] = 0.0f; sunEmissionMaterial[2] = 0.0f; glMaterialfv(GL_FRONT, GL_EMISSION, sunEmissionMaterial); glPopMatrix(); glPushMatrix(); glUseProgram(g_program); GLuint elap = glGetUniformLocation(g_program, "elapsed"); glUniform1f(elap, NYRenderer::_DeltaTimeCumul); GLuint invView = glGetUniformLocation(g_program, "invertView"); glUniformMatrix4fv(invView, 1, true, g_renderer->_Camera->_InvertViewMatrix.Mat.t); GLuint posCam = glGetUniformLocation(g_program, "posCam"); glUniform3f(posCam, g_renderer->_Camera->_Position.X, g_renderer->_Camera->_Position.Y, g_renderer->_Camera->_Position.X); //g_world->render_world_old_school(); g_world->render_world_vbo(); glUseProgram(0); glPopMatrix(); /* //Rotation du cube en fonction du temps glRotatef(NYRenderer::_DeltaTimeCumul*50.0f, 0, 0, 1); glRotatef(NYRenderer::_DeltaTimeCumul*50.0f, 0, 1, 0); //ROTATION glRotatef(NYRenderer::_DeltaTimeCumul * 100, g_slider->Value*10.0f, 1, cos(NYRenderer::_DeltaTimeCumul)); //glTranslatef(2, 2, 0); //glRotatef(45, 0, 0, 1); //BACK FACE CULLING //glDisable(GL_CULL_FACE); //MATERIALS GLfloat materialDiffuseR[] = { 0.7, 0, 0, 1.0 }; GLfloat materialAmbientR[] = { 0.7, 0, 0, 1.0 }; GLfloat materialDiffuseG[] = { 0, 0.7, 0, 1.0 }; GLfloat materialAmbientG[] = { 0, 0.7, 0, 1.0 }; GLfloat materialDiffuseB[] = { 0, 0, 0.7, 1.0 }; GLfloat materialAmbientB[] = { 0, 0, 0.7, 1.0 }; //CUBE glBegin(GL_QUADS); //Face1 glMaterialfv(GL_FRONT, GL_DIFFUSE, materialDiffuseG); glMaterialfv(GL_FRONT, GL_AMBIENT, materialAmbientG); glColor3d(0, 0.5f, 0); glNormal3f(0, -1, 0); glVertex3f(-1, -1, -1); glVertex3f(1, -1, -1); glVertex3f(1, -1, 1); glVertex3f(-1, -1, 1); //Face2 glColor3d(0, 0.5f, 0); glNormal3f(0, 1, 0); glVertex3f(-1, 1, -1); glVertex3f(-1, 1, 1); glVertex3f(1, 1, 1); glVertex3f(1, 1, -1); //Face3 glMaterialfv(GL_FRONT, GL_DIFFUSE, materialDiffuseR); glMaterialfv(GL_FRONT, GL_AMBIENT, materialAmbientR); glColor3d(0.5f, 0, 0); glNormal3f(1, 0, 0); glVertex3f(1, -1, -1); glVertex3f(1, 1, -1); glVertex3f(1, 1, 1); glVertex3f(1, -1, 1); //Face4 glColor3d(0.5f, 0, 0); glNormal3f(-1, 0, 0); glVertex3f(-1, -1, -1); glVertex3f(-1, -1, 1); glVertex3f(-1, 1, 1); glVertex3f(-1, 1, -1); //Face5 glMaterialfv(GL_FRONT, GL_DIFFUSE, materialDiffuseB); glMaterialfv(GL_FRONT, GL_AMBIENT, materialAmbientB); glColor3d(0, 0, 0.5f); glNormal3f(0, 0, 1); glVertex3f(-1, -1, 1); glVertex3f(1, -1, 1); glVertex3f(1, 1, 1); glVertex3f(-1, 1, 1); //Face6 glColor3d(0, 0, 0.5f); glNormal3f(0, 0, -1); glVertex3f(-1, -1, -1); glVertex3f(-1, 1, -1); glVertex3f(1, 1, -1); glVertex3f(1, -1, -1); glEnd(); glPopMatrix(); //SPHERE //Diffuse GLfloat materialDiffuse[] = { 0.5, 0.5, 0.5, 0.5 }; glMaterialfv(GL_FRONT, GL_DIFFUSE, materialDiffuse); //Speculaire GLfloat whiteSpecularMaterial[] = { 0.3, 0.3, 0.3, 0.5 }; glMaterialfv(GL_FRONT, GL_SPECULAR, whiteSpecularMaterial); GLfloat mShininess = 100; glMaterialf(GL_FRONT, GL_SHININESS, mShininess); glutSolidSphere(3,50,50); */ }
int main(int argc, char **argv) { static GLfloat lightpos[] = {25.f, 50.f, -50.f, 1.f}; static GLfloat sphere_mat[] = {1.f, .5f, 0.f, 1.f}; static GLfloat cone_mat[] = {0.f, .5f, 1.f, 1.f}; GLUquadricObj *sphere, *cone, *base; glutInit(&argc, argv); glutInitWindowSize(512, 512); glutInitDisplayMode(GLUT_STENCIL | GLUT_DEPTH | GLUT_DOUBLE); (void) glutCreateWindow("csg"); glutDisplayFunc(redraw); glutKeyboardFunc(key); glutSpecialFunc(special); glutMouseFunc(mouse); glutMotionFunc(motion); glutCreateMenu(menu); glutAddMenuEntry("A only", CSG_A); glutAddMenuEntry("B only", CSG_B); glutAddMenuEntry("A or B", CSG_A_OR_B); glutAddMenuEntry("A and B", CSG_A_AND_B); glutAddMenuEntry("A sub B", CSG_A_SUB_B); glutAddMenuEntry("B sub A", CSG_B_SUB_A); glutAttachMenu(GLUT_RIGHT_BUTTON); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_POSITION, lightpos); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); /* make display lists for sphere and cone; for efficiency */ glNewList(SPHERE, GL_COMPILE); sphere = gluNewQuadric(); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, sphere_mat); gluSphere(sphere, 20.f, 64, 64); gluDeleteQuadric(sphere); glEndList(); glNewList(CONE, GL_COMPILE); cone = gluNewQuadric(); base = gluNewQuadric(); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, cone_mat); gluQuadricOrientation(base, GLU_INSIDE); gluDisk(base, 0., 15., 64, 1); gluCylinder(cone, 15., 0., 60., 64, 64); gluDeleteQuadric(cone); gluDeleteQuadric(base); glEndList(); glMatrixMode(GL_PROJECTION); glOrtho(-50., 50., -50., 50., -50., 50.); glMatrixMode(GL_MODELVIEW); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
ENTRYPOINT void init_cow (ModeInfo *mi) { cow_configuration *bp; int wire = MI_IS_WIREFRAME(mi); int i; Bool tex_p = False; MI_INIT (mi, bps); bp = &bps[MI_SCREEN(mi)]; bp->glx_context = init_GL(mi); reshape_cow (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.4, 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 (False); bp->dlists = (GLuint *) calloc (countof(all_objs)+1, sizeof(GLuint)); for (i = 0; i < countof(all_objs); i++) bp->dlists[i] = glGenLists (1); tex_p = load_texture (mi, do_texture); if (tex_p) glBindTexture (GL_TEXTURE_2D, bp->texture); for (i = 0; i < countof(all_objs); i++) { GLfloat black[4] = {0, 0, 0, 1}; const struct gllist *gll = *all_objs[i]; glNewList (bp->dlists[i], GL_COMPILE); glDisable (GL_TEXTURE_2D); if (i == HIDE) { GLfloat color[4] = {0.63, 0.43, 0.36, 1.00}; if (tex_p) { /* if we have a texture, make the base color be white. */ color[0] = color[1] = color[2] = 1.0; glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_2D); /* approximately line it up with ../images/earth.png */ glMatrixMode (GL_TEXTURE); glLoadIdentity(); glTranslatef (0.45, 0.58, 0); glScalef (0.08, 0.16, 1); glRotatef (-5, 0, 0, 1); glMatrixMode (GL_MODELVIEW); } glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, black); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128); } else if (i == TAIL) { GLfloat color[4] = {0.63, 0.43, 0.36, 1.00}; glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, black); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128); } else if (i == UDDER) { GLfloat color[4] = {1.00, 0.53, 0.53, 1.00}; glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, black); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128); } else if (i == HOOFS || i == HORNS) { GLfloat color[4] = {0.20, 0.20, 0.20, 1.00}; GLfloat spec[4] = {0.30, 0.30, 0.30, 1.00}; GLfloat shiny = 8.0; glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny); } else if (i == FACE) { GLfloat color[4] = {0.10, 0.10, 0.10, 1.00}; GLfloat spec[4] = {0.10, 0.10, 0.10, 1.00}; GLfloat shiny = 8.0; glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny); } else { GLfloat color[4] = {1.00, 1.00, 1.00, 1.00}; GLfloat spec[4] = {1.00, 1.00, 1.00, 1.00}; GLfloat shiny = 128.0; glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny); } renderList (gll, wire); 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]; f->rot = make_rotator (10.0, 0, 0, 4, 0.05 * speed, True); if (bp->nfloaters == 2) { f->x = (i ? 6 : -6); } else if (i != 0) { double th = (i - 1) * M_PI*2 / (bp->nfloaters-1); double r = 10; 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); } }
// DRAW //------------------------------------------------- void Object3D::Draw () { // daca nu este vizibil, nu-l desenam if(!Visible) return; glPushMatrix(); // translatie glTranslatef( translation.x , translation.y , translation.z ); // rotatie glRotatef( rotation.x , 1.0 , 0.0 , 0.0 ); glRotatef( rotation.y , 0.0 , 1.0 , 0.0 ); glRotatef( rotation.z , 0.0 , 0.0 , 1.0 ); // scalare glScalef( scale.x , scale.y , scale.z); // setari de material : // daca nu este selectat if( !selected ) { // culoare normala glColor3f(color.x,color.y,color.z); glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,(Vector4D(color.x,color.y,color.z,1)).Array()); } else { // culoarea atunci cand obiectul este selectat glColor3f(SelectedColor.x, SelectedColor.y, SelectedColor.z); glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,(Vector4D(SelectedColor.x,SelectedColor.y,SelectedColor.z,1)).Array()); } // culoare speculara, default glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,(Vector4D(0.1,0.1,0.1,1)).Array()); //culoae emisiva if(emission==true) glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Vector4D(Vector4D(color.x,color.y,color.z,1)).Array()); else glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Vector4D(0, 0, 0, 0).Array()); // daca este wireframe if( Wireframe ) switch( Type ) { // cub wireframe case Cube : glutWireCube(1.0); break; // sfera wireframe case Sphere : glutWireSphere(1.0, levelOfDetail, levelOfDetail); break; // ceainic wireframe case MyTeapot: glutWireTeapot(1); break; // lampa wireframe case MyLamp: glutWireCone(1.0,2.0,(int)levelOfDetail,(int)levelOfDetail); break; // inamic wireframe case MyEnemy: glutWireDodecahedron(); break; // extra inamic wireframe case ExtraEnemy: glutWireTetrahedron(); break; // orice alt obiect, specificat de programator case Custom : customDraw(); } // daca nu este wireframe else switch( Type ) { // cub solid case Cube : glutSolidCube(1.0); break; // sfera solida case Sphere : glutSolidSphere(1.0, levelOfDetail, levelOfDetail); break; // ceainic solid case MyTeapot: glutSolidTeapot(1); break; // lampa solida case MyLamp: glutSolidCone(1.0,2.0,(int)levelOfDetail,(int)levelOfDetail); break; // inamic solid case MyEnemy: glutSolidDodecahedron(); // extra inamic solid case ExtraEnemy: glutSolidTetrahedron(); break; // orice alt obiect, specificat de programator case Custom : customDraw(); } glPopMatrix(); }
IGL_INLINE void igl::opengl2::draw_floor_outline(const float * colorA, const float * colorB, const int GridSizeX, const int GridSizeY) { const float SizeX = 0.5f*100./(double)GridSizeX; const float SizeY = 0.5f*100./(double)GridSizeY; float old_line_width =0; // old settings int old_lighting=0,old_color_material=0; glGetIntegerv(GL_LIGHTING,&old_lighting); glGetIntegerv(GL_COLOR_MATERIAL,&old_color_material); glDisable(GL_LIGHTING); // Set material const float black[] = {0.,0.,0.,1.}; glMaterialfv(GL_FRONT, GL_AMBIENT, black); glMaterialfv(GL_FRONT, GL_DIFFUSE, black); glMaterialfv(GL_FRONT, GL_SPECULAR, black); glMaterialfv(GL_FRONT, GL_EMISSION, black); glMaterialf(GL_FRONT, GL_SHININESS,0); const bool use_lighting = false; if(use_lighting) { glEnable(GL_LIGHTING); }else { glDisable(GL_LIGHTING); } glLineWidth(2.0f); glBegin(GL_LINES); for (int x =-GridSizeX/2;x<=GridSizeX/2;++x) { if(x!=(GridSizeX/2)) { for(int s = -1;s<2;s+=2) { int y = s*(GridSizeY/2); int cy = y==(GridSizeY/2) ? y-1 : y; if ((x+cy)&0x00000001) //modulo 2 { glColor4fv(colorA); //glColor3f(1,0,0); }else { glColor4fv(colorB); //glColor3f(0,0,1); } glVertex3f((x+1)*SizeX,0,y*SizeY); glVertex3f( x*SizeX,0,y*SizeY); } } if(x==-(GridSizeX/2) || x==(GridSizeX/2)) { int cx = x==(GridSizeX/2) ? x-1 : x; for (int y =-GridSizeY/2;y<GridSizeY/2;++y) { if ((cx+y)&0x00000001) //modulo 2 { glColor4fv(colorA); //glColor3f(1,0,0); }else { glColor4fv(colorB); //glColor3f(0,0,1); } glVertex3f(x*SizeX,0,(y+1)*SizeY); glVertex3f(x*SizeX,0, y*SizeY); } } } glEnd(); glGetFloatv(GL_LINE_WIDTH,&old_line_width); glLineWidth(old_line_width); (old_lighting ? glEnable(GL_LIGHTING) : glDisable(GL_LIGHTING)); (old_color_material? glEnable(GL_COLOR_MATERIAL) : glDisable(GL_COLOR_MATERIAL)); }
void display(void) { GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 }; GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 }; GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 }; GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 }; GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat no_shininess[] = { 0.0 }; GLfloat low_shininess[] = { 5.0 }; GLfloat high_shininess[] = { 100.0 }; GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0}; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* draw sphere in first row, first column * diffuse reflection only; no ambient or specular */ glPushMatrix(); glTranslatef (-3.75, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in first row, second column * diffuse and specular reflection; low shininess; no ambient */ glPushMatrix(); glTranslatef (-1.25, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in first row, third column * diffuse and specular reflection; high shininess; no ambient */ glPushMatrix(); glTranslatef (1.25, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in first row, fourth column * diffuse reflection; emission; no ambient or specular reflection */ glPushMatrix(); glTranslatef (3.75, 3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in second row, first column * ambient and diffuse reflection; no specular */ glPushMatrix(); glTranslatef (-3.75, 0.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in second row, second column * ambient, diffuse and specular reflection; low shininess */ glPushMatrix(); glTranslatef (-1.25, 0.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in second row, third column * ambient, diffuse and specular reflection; high shininess */ glPushMatrix(); glTranslatef (1.25, 0.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in second row, fourth column * ambient and diffuse reflection; emission; no specular */ glPushMatrix(); glTranslatef (3.75, 0.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in third row, first column * colored ambient and diffuse reflection; no specular */ glPushMatrix(); glTranslatef (-3.75, -3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in third row, second column * colored ambient, diffuse and specular reflection; low shininess */ glPushMatrix(); glTranslatef (-1.25, -3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in third row, third column * colored ambient, diffuse and specular reflection; high shininess */ glPushMatrix(); glTranslatef (1.25, -3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, no_mat); glutSolidSphere(1.0, 16, 16); glPopMatrix(); /* draw sphere in third row, fourth column * colored ambient and diffuse reflection; emission; no specular */ glPushMatrix(); glTranslatef (3.75, -3.0, 0.0); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat); glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission); glutSolidSphere(1.0, 16, 16); glPopMatrix(); glFlush(); }
void INIT(void) { printf("Morph 3D - Shows morphing platonic polyhedra\n"); printf("Author: Marcelo Fernandes Vianna ([email protected])\n\n"); printf(" [1] - Tetrahedron\n"); printf(" [2] - Hexahedron (Cube)\n"); printf(" [3] - Octahedron\n"); printf(" [4] - Dodecahedron\n"); printf(" [5] - Icosahedron\n"); printf(" [s] - Slow, more sleep time\n"); printf(" [f] - Faster,less sleep time\n"); printf("[SPACE] - Toggle colored faces\n"); printf("[RETURN] - Toggle smooth/flat shading\n"); printf(" [ESC] - Quit\n"); object=1; glutInitWindowPosition(0,0); glutInitWindowSize(640,480); glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB ); if (glutCreateWindow("Morph 3D - Shows morphing platonic polyhedra") <= 0) { exit(0); } glClearDepth(1.0); glClearColor( 0.0, 0.0, 0.0, 1.0 ); glColor3f( 1.0, 1.0, 1.0 ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glFlush(); glutSwapBuffers(); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular); glHint(GL_FOG_HINT, GL_FASTEST); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST); pinit(); glutReshapeFunc( reshape ); glutKeyboardFunc( key ); glutIdleFunc( idle_ ); glutDisplayFunc( draw ); glutMainLoop(); }
//////////////////////////////////////////////////////////////////////// /// /// @fn void Modele3D::appliquerMateriau( const aiMaterial* materiau ) /// /// Cette fonction applique un matériau 'assimp' à l'état OpenGL /// courant (puisque certains meshes peuvent en dépendre). Le code est /// chaotique; rassurons-nous cette fonction ne fait qu'effectuer /// des appels OpenGL selon l'état de la structure interne du matériau /// 'assimp' ainsi que quelques calculs. /// /// @param[in] materiau : matériau 'assimp' à appliquer /// /// @return Aucune. /// //////////////////////////////////////////////////////////////////////// void Modele3D::appliquerMateriau(const aiMaterial* materiau) { // Obtenir la texture du matériau int indexTexture = 0; aiString nomFichier = ""; glMatrixMode(GL_TEXTURE); glPushMatrix(); if (materiau->GetTexture(aiTextureType_DIFFUSE, indexTexture, &nomFichier) == AI_SUCCESS) { // Activer le texturage OpenGL et lier la texture appropriée glEnable ( GL_TEXTURE_2D); GLuint* idTexture = mapTextures_[nomFichier.data]; glScalef(1.0,-1.0,1.0); glBindTexture(GL_TEXTURE_2D, *idTexture); } else { // Désactiver le texturage OpenGL puisque cet objet n'a aucune texture glDisable ( GL_TEXTURE_2D); } glMatrixMode(GL_MODELVIEW); // Autres paramètres à appliquer... (couleurs) float c[4]; GLenum fill_mode; int ret1, ret2; struct aiColor4D diffuse; struct aiColor4D specular; struct aiColor4D ambient; struct aiColor4D emission; float shininess, strength; int two_sided; int wireframe; unsigned int max; // changé pour: unsigned assignerFloat4(c, 0.8f, 0.8f, 0.8f, 1.0f); //assignerFloat4(c, 1.0f, 1.0f, 1.0f, 1.0f); if (aiGetMaterialColor(materiau, AI_MATKEY_COLOR_DIFFUSE, &diffuse) == AI_SUCCESS) couleurVersFloat4(&diffuse, c); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c); assignerFloat4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(materiau, AI_MATKEY_COLOR_SPECULAR, &specular)) couleurVersFloat4(&specular, c); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); assignerFloat4(c, 0.2f, 0.2f, 0.2f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(materiau, AI_MATKEY_COLOR_AMBIENT, &ambient)) couleurVersFloat4(&ambient, c); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c); assignerFloat4(c, 0.0f, 0.0f, 0.0f, 1.0f); if(AI_SUCCESS == aiGetMaterialColor(materiau, AI_MATKEY_COLOR_EMISSIVE, &emission)) couleurVersFloat4(&emission, c); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c); max = 1; ret1 = aiGetMaterialFloatArray(materiau, AI_MATKEY_SHININESS, &shininess, &max); max = 1; ret2 = aiGetMaterialFloatArray(materiau, AI_MATKEY_SHININESS_STRENGTH, &strength, &max); if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS)) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength); else { glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f); assignerFloat4(c, 0.0f, 0.0f, 0.0f, 0.0f); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c); } max = 1; if(AI_SUCCESS == aiGetMaterialIntegerArray(materiau, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max)) fill_mode = wireframe ? GL_LINE : GL_FILL; else fill_mode = GL_FILL; glPolygonMode(GL_FRONT_AND_BACK, fill_mode); max = 1; if((AI_SUCCESS == aiGetMaterialIntegerArray(materiau, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); }
static void draw_dodeca( void ) { GLuint list; #define TAU ((SQRT5+1)/2) list = glGenLists( 1 ); glNewList( list, GL_COMPILE ); PENTAGON(1,seno,edgedivisions,sqr(TAU) * sqrt((TAU+2)/5) / 2); glEndList(); glPushMatrix(); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); glCallList(list); glRotatef(180,0,0,1); glPushMatrix(); glRotatef(-dodecaangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,-sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(dodecaangle,cos36,-sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); glCallList(list); glPopMatrix(); glRotatef(dodecaangle,cos36,sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); glCallList(list); glPopMatrix(); glRotatef(180,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); glCallList(list); glRotatef(180,0,0,1); glPushMatrix(); glRotatef(-dodecaangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[8]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(-dodecaangle,cos72,-sin72,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[9]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(dodecaangle,cos36,-sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[10]); glCallList(list); glPopMatrix(); glRotatef(dodecaangle,cos36,sin36,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[11]); glCallList(list); glDeleteLists(list,1); }
static void draw_ico( void ) { GLuint list; list = glGenLists( 1 ); glNewList( list, GL_COMPILE ); TRIANGLE(1.5,seno,edgedivisions,(3*SQRT3+SQRT15)/12); glEndList(); glPushMatrix(); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[0]); glCallList(list); glPushMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[1]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[2]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[3]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[4]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[5]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[6]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[7]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[8]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[9]); glCallList(list); glPopMatrix(); glRotatef(180,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[10]); glCallList(list); glPushMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[11]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[12]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[13]); glCallList(list); glPopMatrix(); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[14]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[15]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[16]); glCallList(list); glPopMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[17]); glCallList(list); glPushMatrix(); glRotatef(180,0,1,0); glRotatef(-180+icoangle,0.5,-SQRT3/2,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[18]); glCallList(list); glPopMatrix(); glRotatef(180,0,0,1); glRotatef(-icoangle,1,0,0); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor[19]); glCallList(list); glDeleteLists(list,1); }
void RenderingEngine::Initialize(const vector<ISurface*>& surfaces) { vector<ISurface*>::const_iterator surface; for (surface = surfaces.begin(); surface != surfaces.end(); ++surface) { // Create the VBO for the vertices. vector<float> vertices; (*surface)->GenerateVertices(vertices, VertexFlagsNormals); GLuint vertexBuffer; glGenBuffers(1, &vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(vertices[0]), &vertices[0], GL_STATIC_DRAW); // Create a VBO for the triangle indices. int triangleIndexCount = (*surface)->GetTriangleIndexCount(); vector<GLushort> triangleIndices(triangleIndexCount); (*surface)->GenerateTriangleIndices(triangleIndices); GLuint triangleIndexBuffer; glGenBuffers(1, &triangleIndexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, triangleIndexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, triangleIndexCount * sizeof(GLushort), &triangleIndices[0], GL_STATIC_DRAW); // Create a VBO for the line indices. int lineIndexCount = (*surface)->GetTriangleIndexCount(); vector<GLushort> lineIndices(lineIndexCount); (*surface)->GenerateLineIndices(lineIndices); GLuint lineIndexBuffer; glGenBuffers(1, &lineIndexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, lineIndexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, lineIndexCount * sizeof(GLushort), &lineIndices[0], GL_STATIC_DRAW); Drawable drawable = { vertexBuffer, triangleIndexBuffer, lineIndexBuffer, triangleIndexCount, lineIndexBuffer }; m_drawables.push_back(drawable); } #ifndef MACOSX // Extract width and height from the color buffer. int width, height; glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_WIDTH_OES, &width); glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_HEIGHT_OES, &height); // Create a depth buffer that has the same size as the color buffer. glGenRenderbuffersOES(1, &m_depthRenderbuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_depthRenderbuffer); glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, width, height); // Create the framebuffer object. GLuint framebuffer; glGenFramebuffersOES(1, &framebuffer); glBindFramebufferOES(GL_FRAMEBUFFER_OES, framebuffer); glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, m_colorRenderbuffer); glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, m_depthRenderbuffer); glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_colorRenderbuffer); #endif // Set up various GL state. glEnableClientState(GL_VERTEX_ARRAY); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glShadeModel(GL_FLAT); glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); // Set up the material properties. vec4 ambient(0.2f, 0.2f, 0.2f, 1); vec4 specular(0.5f, 0.5f, 0.5f, 1); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient.Pointer()); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.Pointer()); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 30.0f); m_translation = mat4::Translate(0, 0, -7); }
void ofMaterial::begin() { #ifndef TARGET_OPENGLES // save previous values, opengl es cannot use push/pop attrib glGetMaterialfv(GL_FRONT,GL_DIFFUSE,&prev_diffuse.r); glGetMaterialfv(GL_FRONT,GL_SPECULAR,&prev_specular.r); glGetMaterialfv(GL_FRONT,GL_AMBIENT,&prev_ambient.r); glGetMaterialfv(GL_FRONT,GL_EMISSION,&prev_emissive.r); glGetMaterialfv(GL_FRONT, GL_SHININESS, &prev_shininess); glGetMaterialfv(GL_BACK,GL_DIFFUSE,&prev_diffuse_back.r); glGetMaterialfv(GL_BACK,GL_SPECULAR,&prev_specular_back.r); glGetMaterialfv(GL_BACK,GL_AMBIENT,&prev_ambient_back.r); glGetMaterialfv(GL_BACK,GL_EMISSION,&prev_emissive_back.r); glGetMaterialfv(GL_BACK, GL_SHININESS, &prev_shininess_back); // Material colors and properties glMaterialfv(GL_FRONT, GL_DIFFUSE, &diffuse.r); glMaterialfv(GL_FRONT, GL_SPECULAR, &specular.r); glMaterialfv(GL_FRONT, GL_AMBIENT, &ambient.r); glMaterialfv(GL_FRONT, GL_EMISSION, &emissive.r); glMaterialfv(GL_FRONT, GL_SHININESS, &shininess); glMaterialfv(GL_BACK, GL_DIFFUSE, &diffuse.r); glMaterialfv(GL_BACK, GL_SPECULAR, &specular.r); glMaterialfv(GL_BACK, GL_AMBIENT, &ambient.r); glMaterialfv(GL_BACK, GL_EMISSION, &emissive.r); glMaterialfv(GL_BACK, GL_SHININESS, &shininess); #else // opengl es 1.1 implementation must use GL_FRONT_AND_BACK. glGetMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &prev_diffuse.r); glGetMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &prev_specular.r); glGetMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &prev_ambient.r); glGetMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &prev_emissive.r); glGetMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &prev_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &shininess); #endif }
void ofMaterial::end() { #ifndef TARGET_OPENGLES // Set previous material colors and properties glMaterialfv(GL_FRONT, GL_DIFFUSE, &prev_diffuse.r); glMaterialfv(GL_FRONT, GL_SPECULAR, &prev_specular.r); glMaterialfv(GL_FRONT, GL_AMBIENT, &prev_ambient.r); glMaterialfv(GL_FRONT, GL_EMISSION, &prev_emissive.r); glMaterialfv(GL_FRONT, GL_SHININESS, &prev_shininess); glMaterialfv(GL_BACK, GL_DIFFUSE, &prev_diffuse_back.r); glMaterialfv(GL_BACK, GL_SPECULAR, &prev_specular_back.r); glMaterialfv(GL_BACK, GL_AMBIENT, &prev_ambient_back.r); glMaterialfv(GL_BACK, GL_EMISSION, &prev_emissive_back.r); glMaterialfv(GL_BACK, GL_SHININESS, &prev_shininess_back); #else // opengl es 1.1 implementation must use GL_FRONT_AND_BACK. glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &prev_diffuse.r); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &prev_specular.r); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &prev_ambient.r); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &prev_emissive.r); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &prev_shininess); #endif }
void EDA_3D_CANVAS::Redraw() { // SwapBuffer requires the window to be shown before calling if( !IsShownOnScreen() ) return; wxString err_messages; WX_STRING_REPORTER errorReporter( &err_messages ); STATUS_TEXT_REPORTER activityReporter( Parent(), 0 ); // Display build time at the end of build unsigned strtime = GetRunningMicroSecs(); SetCurrent( *m_glRC ); // Set the OpenGL viewport according to the client size of this canvas. // This is done here rather than in a wxSizeEvent handler because our // OpenGL rendering context (and thus viewport setting) is used with // multiple canvases: If we updated the viewport in the wxSizeEvent // handler, changing the size of one canvas causes a viewport setting that // is wrong when next another canvas is repainted. wxSize size = GetClientSize(); InitGL(); if( isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) ) { generateFakeShadowsTextures( &errorReporter, &activityReporter ); } // *MUST* be called *after* SetCurrent( ): glViewport( 0, 0, size.x, size.y ); // clear color and depth buffers glClearColor( 0.95, 0.95, 1.0, 1.0 ); glClearStencil( 0 ); glClearDepth( 1.0 ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); glShadeModel( GL_SMOOTH ); // Draw background glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glDisable( GL_LIGHTING ); glDisable( GL_COLOR_MATERIAL ); glDisable( GL_DEPTH_TEST ); glDisable( GL_TEXTURE_2D ); // Draw the background ( rectangle with color gradient) glBegin( GL_QUADS ); SetGLColor( GetPrm3DVisu().m_BgColor_Top, 1.0 ); glVertex2f( -1.0, 1.0 ); // Top left corner SetGLColor( GetPrm3DVisu().m_BgColor, 1.0 ); glVertex2f( -1.0,-1.0 ); // bottom left corner glVertex2f( 1.0,-1.0 ); // bottom right corner SetGLColor( GetPrm3DVisu().m_BgColor_Top, 1.0 ); glVertex2f( 1.0, 1.0 ); // top right corner glEnd(); glEnable( GL_DEPTH_TEST ); // set viewing projection glMatrixMode( GL_PROJECTION ); glLoadIdentity(); #define MAX_VIEW_ANGLE 160.0 / 45.0 if( GetPrm3DVisu().m_Zoom > MAX_VIEW_ANGLE ) GetPrm3DVisu().m_Zoom = MAX_VIEW_ANGLE; if( Parent()->ModeIsOrtho() ) { // OrthoReductionFactor is chosen to provide roughly the same size as // Perspective View const double orthoReductionFactor = 400 / GetPrm3DVisu().m_Zoom; // Initialize Projection Matrix for Ortographic View glOrtho( -size.x / orthoReductionFactor, size.x / orthoReductionFactor, -size.y / orthoReductionFactor, size.y / orthoReductionFactor, 1, 100 ); } else { // Ratio width / height of the window display double ratio_HV = (double) size.x / size.y; // Initialize Projection Matrix for Perspective View gluPerspective( 45.0f * GetPrm3DVisu().m_Zoom, ratio_HV, 1, 100 ); } // position viewer glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef( 0.0f, 0.0f, -(m_ZBottom + m_ZTop) / 2.0f ); // Setup light sources: SetLights(); CheckGLError( __FILE__, __LINE__ ); glMatrixMode( GL_MODELVIEW ); // position viewer // transformations GLfloat mat[4][4]; // Translate motion first, so rotations don't mess up the orientation... glTranslatef( m_draw3dOffset.x, m_draw3dOffset.y, 0.0F ); build_rotmatrix( mat, GetPrm3DVisu().m_Quat ); glMultMatrixf( &mat[0][0] ); glRotatef( GetPrm3DVisu().m_Rot[0], 1.0, 0.0, 0.0 ); glRotatef( GetPrm3DVisu().m_Rot[1], 0.0, 1.0, 0.0 ); glRotatef( GetPrm3DVisu().m_Rot[2], 0.0, 0.0, 1.0 ); if( ! m_glLists[GL_ID_BOARD] || ! m_glLists[GL_ID_TECH_LAYERS] ) CreateDrawGL_List( &errorReporter, &activityReporter ); if( isEnabled( FL_AXIS ) && m_glLists[GL_ID_AXIS] ) glCallList( m_glLists[GL_ID_AXIS] ); // move the board in order to draw it with its center at 0,0 3D coordinates glTranslatef( -GetPrm3DVisu().m_BoardPos.x * GetPrm3DVisu().m_BiuTo3Dunits, -GetPrm3DVisu().m_BoardPos.y * GetPrm3DVisu().m_BiuTo3Dunits, 0.0f ); if( isEnabled( FL_MODULE ) ) { if( ! m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] ) CreateDrawGL_List( &errorReporter, &activityReporter ); } glEnable( GL_LIGHTING ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); if( isRealisticMode() && isEnabled( FL_RENDER_TEXTURES ) ) glEnable( GL_TEXTURE_2D ); else glDisable( GL_TEXTURE_2D ); // Set material for the board glEnable( GL_COLOR_MATERIAL ); SetOpenGlDefaultMaterial(); //glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, FALSE ); // Board Body GLint shininess_value = 32; glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value ); if( isEnabled( FL_SHOW_BOARD_BODY ) ) { if( m_glLists[GL_ID_BODY] ) { glCallList( m_glLists[GL_ID_BODY] ); } } // Board // specify material parameters for the lighting model. shininess_value = 52; glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value ); glm::vec4 specular( GetPrm3DVisu().m_CopperColor.m_Red * 0.20f, GetPrm3DVisu().m_CopperColor.m_Green * 0.20f, GetPrm3DVisu().m_CopperColor.m_Blue * 0.20f, 1.0f ); glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.x ); if( m_glLists[GL_ID_BOARD] ) { glCallList( m_glLists[GL_ID_BOARD] ); } // Tech layers shininess_value = 32; glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value ); glm::vec4 specularTech( 0.0f, 0.0f, 0.0f, 1.0f ); glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specularTech.x ); if( m_glLists[GL_ID_TECH_LAYERS] ) { glCallList( m_glLists[GL_ID_TECH_LAYERS] ); } if( isEnabled( FL_COMMENTS ) || isEnabled( FL_ECO ) ) { if( ! m_glLists[GL_ID_AUX_LAYERS] ) CreateDrawGL_List( &errorReporter, &activityReporter ); glCallList( m_glLists[GL_ID_AUX_LAYERS] ); } //glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, TRUE ); // Draw Component Shadow if( isEnabled( FL_MODULE ) && isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) ) { glEnable( GL_CULL_FACE ); glDisable( GL_DEPTH_TEST ); glEnable( GL_COLOR_MATERIAL ) ; SetOpenGlDefaultMaterial(); glColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); glEnable( GL_TEXTURE_2D ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); if( m_glLists[GL_ID_SHADOW_FRONT] ) { glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_front ); glCallList( m_glLists[GL_ID_SHADOW_FRONT] ); } if( m_glLists[GL_ID_SHADOW_BACK] ) { glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_back ); glCallList( m_glLists[GL_ID_SHADOW_BACK] ); } glColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); glEnable( GL_DEPTH_TEST ); glDisable( GL_TEXTURE_2D ); glDisable( GL_CULL_FACE ); } glEnable( GL_COLOR_MATERIAL ); SetOpenGlDefaultMaterial(); glDisable( GL_BLEND ); // Draw Solid Shapes if( isEnabled( FL_MODULE ) ) { if( ! m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] ) CreateDrawGL_List( &errorReporter, &activityReporter ); glCallList( m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] ); } glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // Grid uses transparency: draw it after all objects if( isEnabled( FL_GRID ) ) { if( ! m_glLists[GL_ID_GRID] ) CreateDrawGL_List( &errorReporter, &activityReporter ); glCallList( m_glLists[GL_ID_GRID] ); } // Draw Board Shadow if( isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) ) { if( m_glLists[GL_ID_SHADOW_BOARD] ) { glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glColor4f( 1.0, 1.0, 1.0, 0.75f ); glEnable( GL_CULL_FACE ); glDisable( GL_COLOR_MATERIAL ); glEnable( GL_TEXTURE_2D ); glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_board ); glCallList( m_glLists[GL_ID_SHADOW_BOARD] ); glDisable( GL_CULL_FACE ); glDisable( GL_TEXTURE_2D ); } } // This list must be drawn last, because it contains the // transparent gl objects, which should be drawn after all // non transparent objects if( isEnabled( FL_MODULE ) && m_glLists[GL_ID_3DSHAPES_TRANSP_FRONT] ) { glEnable( GL_COLOR_MATERIAL ); SetOpenGlDefaultMaterial(); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glCallList( m_glLists[GL_ID_3DSHAPES_TRANSP_FRONT] ); } // Debug bounding boxes /* glDisable( GL_BLEND ); glDisable( GL_COLOR_MATERIAL ); glDisable( GL_LIGHTING ); glColor4f( 1.0f, 0.0f, 1.0f, 1.0f ); m_fastAABBox_Shadow.GLdebug(); glColor4f( 0.0f, 1.0f, 1.0f, 1.0f ); m_boardAABBox.GLdebug(); */ SwapBuffers(); // Show calculation time if some activity was reported if( activityReporter.HasMessage() ) { // Calculation time in seconds double calculation_time = (double)( GetRunningMicroSecs() - strtime) / 1e6; activityReporter.Report( wxString::Format( _( "Build time %.3f s" ), calculation_time ) ); } else activityReporter.Report( wxEmptyString ); if( !err_messages.IsEmpty() ) wxLogMessage( err_messages ); }
void draw_scene() { static float ang_self = 0.0; /*Define the angle of self-rotate */ static float angle = 0.0; glLightfv(GL_LIGHT4, GL_POSITION, lit4_position); glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, lit4_direction); glLightfv(GL_LIGHT5, GL_POSITION, lit5_position); glLightfv(GL_LIGHT5, GL_SPOT_DIRECTION, lit5_direction); glLightfv(GL_LIGHT1, GL_POSITION, lit1_position); /*fixed position---*/ glDisable(GL_TEXTURE_2D); draw_floor(); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(0.0, 0.0, 0.0); glMatrixMode(GL_MODELVIEW); draw_slope(); draw_axes(); draw_object(); /*-------Draw the billboard ----*/ glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBindTexture(GL_TEXTURE_2D, textName[2]); glEnable(GL_TEXTURE_2D); draw_billboard(5.0*4.0, -3.0*4.0, 5.0, 8.0); draw_billboard(6.0*4.0, -5.0*4.0, 5.0, 8.0); draw_billboard(3.0*4.0, -6.0*4.0, 5.0, 8.0); draw_billboard(2.0*4.0, -7.0*4.0, 5.0, 8.0); draw_billboard(7.0*4.0, -2.0*4.0, 5.0, 8.0); glDisable(GL_TEXTURE_2D); /*-------Draw the car body which is a cube----*/ glTranslatef(position[0], position[1], position[2]); glRotatef(-up_ang, 1.0, 0.0, 0.0); glRotatef(self_ang, 0.0, 1.0, 0.0); glPushMatrix(); /* Save M1 coord. sys */ draw_cube(); glPopMatrix(); /* Get M1 back */ /*-------Draw the front wheels -----*/ glColor3f(1.0, 0.0, 0.0); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(-4.0, 0.0, 3.0); /* Go to left wheel position */ glutSolidTorus(0.5, /* inner radius */ 1.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(-4.0, 0.0, -3.0);/* Go to right wheel position */ glutSolidTorus(0.5, /* inner radius */ 1.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); /*------Draw back wheels ----*/ glColor3f(1.0, 0.4, 0.0); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(6.0, 0.0, 0.0); /* Go to left wheel position */ glutSolidTorus(0.5, /* inner radius */ 1.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glColor3f(1.0, 0.4, 0.4); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(0.0, 1.5, 7.5); /* Go to left wheel position */ glRotatef(-90.0, 1.0, 0.0, 0.0); glutSolidTorus(0.5, /* inner radius */ 3.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glColor3f(1.0, 0.4, 0.4); glPushMatrix(); /* Save M1 coord. sys */ glTranslatef(0.0, 1.5, -7.5); /* Go to left wheel position */ glRotatef(-90.0, 1.0, 0.0, 0.0); glutSolidTorus(0.5, /* inner radius */ 3.0, /* outer radius */ 24, /* divided into 18 segments */ 12); /* 12 rings */ glPopMatrix(); glColor3f(1.0, 1.0, 1.0); glPushMatrix(); glTranslatef(0.0, 1.5, 7.5); glRotatef(bld_ang, 0.0, 1.0, 0.0); draw_blade();/* draw the first blade */ glRotatef(120, 0.0, 1.0, 0.0); draw_blade();/* draw the first blade */ glRotatef(120, 0.0, 1.0, 0.0); draw_blade();/* draw the first blade */ glPopMatrix(); glColor3f(1.0, 1.0, 1.0); glPushMatrix(); glTranslatef(0.0, 1.5, -7.5); glRotatef(bld_ang, 0.0, 1.0, 0.0); draw_blade(); glRotatef(120, 0.0, 1.0, 0.0); draw_blade(); glRotatef(120, 0.0, 1.0, 0.0); draw_blade(); glPopMatrix(); }
void C3ds::render() { ShaderMgr::get().useProgram(shader); //glVertexPointer(3,GL_FLOAT,0,vertex); //glNormalPointer(GL_FLOAT,0,normal); glEnable(GL_TEXTURE_2D); //glEnable(GL_LIGHTING); //glDisable(GL_BLEND); //glEnable(GL_BLEND); glEnable(GL_COLOR_MATERIAL); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glPushMatrix(); glMaterialfv(GL_FRONT, GL_AMBIENT, (float*) (&ambientColor)); glMaterialfv(GL_FRONT, GL_DIFFUSE, (float*) (&diffuseColor)); glMaterialfv(GL_FRONT, GL_SPECULAR, (float*) (&specColor)); glMaterialf(GL_FRONT, GL_SHININESS, shininess); glScalef(scale, scale, scale); TextureMgr::get().use(texture); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer[1]); glVertexPointer(3, GL_FLOAT, 0, 0); glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer[2]); glNormalPointer(GL_FLOAT, 0, 0); if (numTexCoords == numVerts) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer[3]); glTexCoordPointer(2, GL_FLOAT, 0, 0); } glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buffer[0]); glDrawElements(GL_TRIANGLES, numFaces * 3, GL_UNSIGNED_SHORT, 0); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); /* glBegin(GL_TRIANGLES); for(int i=0;i<numFaces;i++) { //glNormal3f(fnormal[i].x,fnormal[i].y,fnormal[i].z); if(texcoord)glTexCoord2f(texcoord[face[i].p1].u*TexCoordUScale,texcoord[face[i].p1].v*TexCoordVScale); glNormal3f(normal[face[i].p1].x,normal[face[i].p1].y,normal[face[i].p1].z); glVertex3f(vertex[face[i].p1].x,vertex[face[i].p1].y,vertex[face[i].p1].z); if(texcoord)glTexCoord2f(texcoord[face[i].p2].u*TexCoordUScale,texcoord[face[i].p2].v*TexCoordVScale); glNormal3f(normal[face[i].p2].x,normal[face[i].p2].y,normal[face[i].p2].z); glVertex3f(vertex[face[i].p2].x,vertex[face[i].p2].y,vertex[face[i].p2].z); if(texcoord)glTexCoord2f(texcoord[face[i].p3].u*TexCoordUScale,texcoord[face[i].p3].v*TexCoordVScale); glNormal3f(normal[face[i].p3].x,normal[face[i].p3].y,normal[face[i].p3].z); glVertex3f(vertex[face[i].p3].x,vertex[face[i].p3].y,vertex[face[i].p3].z); } glEnd(); */ glPopMatrix(); glDisable(GL_COLOR_MATERIAL); ShaderMgr::get().useNone(); //glEnable(GL_TEXTURE_2D); }
void Display(void) { // バッファのクリア glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // カラーバッファとZバッファの消去 (ステンシルバッファ使うときは、別途(GL_STENCIL_BUFFER_BIT)指定する必要あり) // 座標変換 (ワールド変換 -> ビュー座標変換(カメラ) -> 射影変換 -> クリッピング) // NOTE : なぜか 通常の順序とは逆に、Viewport変換 -> 射影変換 -> モデルビュー変換の順に設定する. // OpenGL的には、カレント変換行列の生成を行っているが、逆からかけていくことによって作られたカレント行列に、モデル行列をかけるだけで、描画位置が決まるようになる. glViewport(0, 0, WindowWidth, WindowHeight); // 射影変換の際に必要な情報 glMatrixMode(GL_PROJECTION); //行列モードの設定(GL_PROJECTION : 透視変換行列の設定、GL_MODELVIEW:モデルビュー変換行列) glLoadIdentity(); // カレント行列の初期化 gluPerspective(30.0, (double)WindowWidth/(double)WindowHeight, 0.1, 1000.0); // 透視投影の視体積 // ビュー変換に必要な情報 (毎loopでカメラを動かしているイメージ) ViewPointY += ( -50.0 - ViewPointY) * 0.001; gluLookAt( 0.0, ViewPointY , ViewPointZ, // 視点の位置x,y,z; 0.0, ViewPointY+200 , 0.0, // 視界の中心位置の参照点座標x,y,z 0.0, 0.0, 1.0 ); //視界の上方向のベクトルx,y,z //モデルビュー変換行列の設定-------------------------- glMatrixMode(GL_MODELVIEW);//行列モードの設定(GL_PROJECTION : 透視変換行列の設定、GL_MODELVIEW:モデルビュー変換行列) glLoadIdentity();//行列の初期化 // 陰影ON--------------------- glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // 光源0を利用 // -------------------------- // NOTE : 光源を利用する際は、glColor3dが無効になるので、オブジェクトの色は`glMaterialfv(適用する面, 光源の種類, 反射する色)`で指定する /* * 複数のオブジェクトを描画する際は、Initializeで作成したカレント行列を元に描画する必要があるので、オブジェクトの描画ごとにカレント行列をPushして、描画おわり次第Popする. */ // 球 glPushMatrix(); // カレント行列をスタックに保存しておく (popされるまでのカレント行列への変更を無視できる) glMaterialfv(GL_FRONT, GL_AMBIENT, ms_ruby.ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, ms_ruby.diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, ms_ruby.specular); glMaterialfv(GL_FRONT, GL_SHININESS, &ms_ruby.shininess); glTranslated(0.0, 10.0, 20.0); // 平行移動値の設定 (OpenGL内部では、カレント行列に平行移動行列を乗算して、カレント行列を更新している) glutSolidSphere(4.0, 20, 20); glPopMatrix(); // 立方体 glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, green); glTranslated(-20.0, 0.0, 20.0); glutSolidCube(10.0); // 引数: 一辺の長さ glPopMatrix(); // 円錐 glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, blue); glTranslated(20.0, 100.0, 0.0); glutSolidCone(5.0, 10.0, 20, 20); // 引数: (半径、高さ、Z軸まわりの分割数、Z軸に沿った分割数) glPopMatrix(); // 直方体 // NOTE 「GLUT」に関数が与えられている球(glutSolidSphere)や立方体(glutSolidCube)の場合には、 // 物体の「表」「裏」の情報に与えたれているが、任意の物体を自前で定義した場合には、各面に対して法線ベクトルを定義する必要がある glPushMatrix(); glMaterialfv(GL_FRONT, GL_AMBIENT, ms_jade.ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, ms_jade.diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, ms_jade.specular); glMaterialfv(GL_FRONT, GL_SHININESS, &ms_jade.shininess); glTranslated(30.0, 50.0, 0.0); // 平行移動値の設定 glBegin(GL_QUADS); for (int j = 0; j < 6; j++) { glNormal3dv(normal[j]); //法線ベクトルの指定 for (int i = 0; i < 4; i++) { glVertex3dv(vertex[face[j][i]]); } } glEnd(); glPopMatrix(); //陰影OFF----------------------------- glDisable(GL_LIGHTING); //----------------------------------- glPushMatrix(); Ground(); glPopMatrix(); glutSwapBuffers(); // glutInitDisplayModel(GLUT_DOUBLE)でダブルバッファリングを可にしているので必要 }
void Material::SelectMaterial(int nmat, int force) { int i; #ifdef MEGADEBUG sprintf (FANTASY_DEBUG_STRING, "->Me piden seleccionar material %d\n",nmat); Debug(DEBUG_LEVEL_OVERDEBUG); #endif if((nmat == last_used_material) && (!force)) return; last_used_material = nmat; if((nmat < numero_materiales) && (nmat >= 0)) { if(materiales[nmat].opaque) // Materiales opacos { #ifdef MEGADEBUG sprintf (FANTASY_DEBUG_STRING, "->Es un material opaco\n"); Debug(DEBUG_LEVEL_OVERDEBUG); #endif if(blend_enabled) { if(force_always_blend) glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); else glDisable(GL_BLEND); glDepthMask(GL_TRUE); blend_enabled=0; } } else // Materiales traslúcidos { if(!blend_enabled) { if(!force_always_blend) glEnable(GL_BLEND); glDepthMask(GL_FALSE); blend_enabled=1; } if(blend_substract_supported) f_glBlendEquationEXT(GL_FUNC_ADD_EXT); switch(materiales[nmat].blend_type) { case BLEND_BLEND: glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); break; case BLEND_ADD: glBlendFunc(GL_SRC_ALPHA,GL_ONE); break; case BLEND_MULTIPLY: glBlendFunc(GL_DST_COLOR,GL_ZERO); break; case BLEND_SUB: if(blend_substract_supported) { glBlendFunc(GL_SRC_ALPHA,GL_ONE); f_glBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT); } break; } } if(materiales[nmat].ntextures) { for(i=0;i<materiales[nmat].ntextures;i++) { if(EXTGL_multitexturing) f_glActiveTextureARB(TextureUnits[i]); if(materiales[nmat].texcoordgen[i] != TEXGEN_CUBE_MAP) { glEnable(GL_TEXTURE_2D); ConjuntoTexturas->SeleccionaTextura(materiales[nmat].textures[i]); } // Seleccionamos el tipo de blend de texturas switch(materiales[nmat].multitexblend[i]) { case BLEND_ADD: glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); break; case BLEND_MODULATE: glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); break; case BLEND_MASK: if(EXTGL_texture_env_combine_supported) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); glTexEnvf(GL_TEXTURE_ENV,GL_SOURCE0_RGB_ARB,GL_PREVIOUS_ARB); glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND0_RGB_ARB,GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV,GL_SOURCE1_RGB_ARB,GL_TEXTURE); glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND1_RGB_ARB,GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV,GL_SOURCE2_RGB_ARB,GL_TEXTURE); glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND2_RGB_ARB,GL_ONE_MINUS_SRC_ALPHA); } break; case BLEND_MASK2: if(EXTGL_texture_env_combine_supported) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); glTexEnvf(GL_TEXTURE_ENV,GL_SOURCE0_RGB_ARB,GL_PREVIOUS_ARB); glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND0_RGB_ARB,GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV,GL_SOURCE1_RGB_ARB,GL_TEXTURE); glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND1_RGB_ARB,GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV,GL_SOURCE2_RGB_ARB,GL_PREVIOUS_ARB); glTexEnvf(GL_TEXTURE_ENV,GL_OPERAND2_RGB_ARB,GL_SRC_ALPHA); } break; case BLEND_DOT3: if(EXTGL_texture_env_dot3_supported) { // UNIT 0 // find dot product of N (stored in the texture map) and L (stored // as the PRIMARY_COLOR). f_glActiveTextureARB(TextureUnits[i-1]); ConjuntoTexturas->SeleccionaTextura(materiales[nmat].textures[i]); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); // UNIT 1 // modulate the base texture by N.L f_glActiveTextureARB(TextureUnits[i]); ConjuntoTexturas->SeleccionaTextura(materiales[nmat].textures[i-1]); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_EXT); glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); } break; case BLEND_REPLACE: glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); break; } // Seleccionamos el tipo de generaci¢n de coord. switch(materiales[nmat].texcoordgen[i]) { case TEXGEN_UV: glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); if(EXTGL_texture_cube_map_supported) glDisable(GL_TEXTURE_CUBE_MAP_ARB); break; case TEXGEN_EYE_LINEAR: { GLfloat xplane[]={1.0f,0.0f,0.0f,0.0f}; GLfloat yplane[]={0.0f,1.0f,0.0f,0.0f}; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); if(EXTGL_texture_cube_map_supported) glDisable(GL_TEXTURE_CUBE_MAP_ARB); xplane[0]=materiales[nmat].linearmultiplier[i]; yplane[1]=materiales[nmat].linearmultiplier[i]; // Lo del glpushmatrix y demás lo cogí de un ejemplo de sgi // que estaba colgado por internet. Aún tengo que saber por que // funciona asi :) glPushMatrix(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTexGenfv(GL_S, GL_EYE_PLANE, xplane); glTexGenfv(GL_T, GL_EYE_PLANE, yplane); glPopMatrix(); } break; case TEXGEN_OBJECT_LINEAR: { GLfloat xplane[]={1.0f,0.0f,0.0f,0.0f}; GLfloat yplane[]={0.0f,1.0f,0.0f,0.0f}; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); if(EXTGL_texture_cube_map_supported) glDisable(GL_TEXTURE_CUBE_MAP_ARB); xplane[0]=materiales[nmat].linearmultiplier[i]; yplane[1]=materiales[nmat].linearmultiplier[i]; glTexGenfv(GL_S, GL_OBJECT_PLANE, xplane); glTexGenfv(GL_T, GL_OBJECT_PLANE, yplane); } break; case TEXGEN_SPHERE_MAP: glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); if(EXTGL_texture_cube_map_supported) glDisable(GL_TEXTURE_CUBE_MAP_ARB); break; case TEXGEN_CUBE_MAP: if(EXTGL_texture_cube_map_supported) { glEnable(GL_TEXTURE_CUBE_MAP_ARB); glDisable(GL_TEXTURE_2D); ConjuntoTexturas->SeleccionaCubeMap(materiales[nmat].textures[i]); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB); glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB); } break; } } if(EXTGL_multitexturing) // Deshabilitamos todas menos la 1¦ { for(i=materiales[nmat].ntextures;i<EXTGL_number_of_texture_units;i++) { f_glActiveTextureARB(TextureUnits[i]); glDisable(GL_TEXTURE_2D); if(EXTGL_texture_cube_map_supported) glDisable(GL_TEXTURE_CUBE_MAP_ARB); } } } else { if(EXTGL_multitexturing) { for(i=1;i<EXTGL_number_of_texture_units;i++) { f_glActiveTextureARB(TextureUnits[i]); glDisable(GL_TEXTURE_2D); } f_glActiveTextureARB(TextureUnits[0]); } ConjuntoTexturas->SeleccionaTextura(0); } if(materiales[nmat].twosided) { if(culling_enabled) { glDisable(GL_CULL_FACE); // Deshabilitamos el testeo de profundidad culling_enabled=0; } } else { if(!culling_enabled) { glCullFace(GL_BACK); glEnable(GL_CULL_FACE); // Habilitamos el testeo de profundidad culling_enabled=1; } } // Finalmente tenemos en cuenta los parámetros para la iluminación glMaterialfv(GL_FRONT,GL_SPECULAR,materiales[nmat].specular); glMaterialfv(GL_FRONT,GL_EMISSION,materiales[nmat].emission); glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,materiales[nmat].shininess); // Ok, la textura está puesta. Sólo nos falta el shader // If there is no shader, shader 0 (NULL) will be selected, meaning no shader program GLSL_SelectShader(&(materiales[nmat])); } }
static void draw_board(antspotlightstruct *mp) { int i, j; double cutoff = Pi/3.0; double center[3]; double centertex[2]; glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, mp->screentexture); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialGray6); /* draw mesh */ /* center is roughly spotlight position */ center[0] = mp->ant->position[0];/* + cos(ant->direction); */ center[1] = 0.0; center[2] = mp->ant->position[2];/* - 0.7*sin(ant->direction);*/ centertex[0] = (mp->boardsize/2.0+center[0]) * mp->max_tx / mp->boardsize; centertex[1] = mp->max_ty - ((mp->boardsize/2.0+center[2]) * mp->max_ty / mp->boardsize); /* glPolygonMode(GL_FRONT, GL_LINE); */ /* glDisable(GL_TEXTURE_2D); */ /* the vertices determined here should correspond to the illuminated board. ideally the code adapts vertex distribution to the intensity and shape of the light. i should be finding the intersection of the cone of light and the board-plane. */ for(i = -12; i < 12; ++i) { double theta1, theta2; glBegin(GL_TRIANGLE_STRIP); glNormal3f(0.0, 1.0, 0.0); glTexCoord2f(centertex[0], centertex[1]); glVertex3f(center[0], 0.01, center[2]); /* watch those constants */ theta1 = mp->ant->direction + i*(cutoff/8); theta2 = mp->ant->direction + (i+1)*(cutoff/8); for(j = 1; j <= 64; ++j) { double point[3], tex[2]; /* double fj = pow(1.05, j) - 1.0;*/ double fj = j / 6.0; point[0] = center[0] + fj*cos(theta1); point[1] = 0.0; point[2] = center[2] - fj*sin(theta1); tex[0] = (mp->boardsize/2.0+point[0]) * mp->max_tx / mp->boardsize; tex[1] = (mp->boardsize/2.0+point[2]) * mp->max_ty / mp->boardsize; glTexCoord2f(tex[0], tex[1]); glVertex3f(point[0], point[1], point[2]); point[0] = center[0] + fj*cos(theta2); point[1] = 0.0; point[2] = center[2] - fj*sin(theta2); tex[0] = (mp->boardsize/2.0+point[0]) * mp->max_tx / mp->boardsize; tex[1] = (mp->boardsize/2.0+point[2]) * mp->max_ty / mp->boardsize; glTexCoord2f(tex[0], tex[1]); glVertex3f(point[0], point[1], point[2]); } glEnd(); } glDisable(GL_TEXTURE_2D); }
//core elements static void arch() { int i, numSlices; double angle; double angInc; glPushMatrix(); glTranslatef(0,0.5,0); glScalef(4,1,2); glutSolidCube(1); glPopMatrix(); glPushMatrix(); glTranslatef(-1.5,-1 ,0); glScalef(1,4,2); glutSolidCube(1); glPopMatrix(); glPushMatrix(); glTranslatef(1.5, -1,0); glScalef(1,4,2); glutSolidCube(1); glPopMatrix(); glPushMatrix(); glMaterialfv(GL_FRONT, GL_AMBIENT, blueWindows); glMaterialfv(GL_FRONT, GL_DIFFUSE, blueWindows); glTranslatef(0,-1.5,0); glScalef(2,3.25,0.125); glutSolidCube(1); glMaterialfv(GL_FRONT, GL_AMBIENT, brickMat); glMaterialfv(GL_FRONT, GL_DIFFUSE, brickMat); glPopMatrix(); glPushMatrix(); glTranslatef(0,-1.75,0); glScalef(3.0,0.25,0.25); glutSolidCube(1); glPopMatrix(); glPushMatrix(); glTranslatef(0.5,-2,0); glScalef(0.25,4,0.25); glutSolidCube(1); glPopMatrix(); glPushMatrix(); glTranslatef(-0.5,-2,0); glScalef(0.25,4,0.25); glutSolidCube(1); glPopMatrix(); numSlices = 20; angle = 0; angInc = 3.14159/(2 * numSlices); for (i = 0; i < numSlices; i++) { glNormal3f(0,0,1); glBegin(GL_POLYGON); glVertex3f(1,0,1); // corner glVertex3f( cos(angle) , sin(angle)-1, 1); glVertex3f( cos(angle+angInc), sin(angle+angInc)-1, 1); glEnd(); glBegin(GL_POLYGON); glVertex3f(-1,0,1); // corner glVertex3f(- cos(angle) , sin(angle)-1, 1); glVertex3f(- cos(angle+angInc), sin(angle+angInc)-1, 1); glEnd(); //--- glNormal3f(0,0,-1); glBegin(GL_POLYGON); glVertex3f(1,0,-1); // corner glVertex3f( cos(angle) , sin(angle)-1, -1); glVertex3f( cos(angle+angInc), sin(angle+angInc)-1, -1); glEnd(); glBegin(GL_POLYGON); glVertex3f(-1,0,-1); // corner glVertex3f(- cos(angle) , sin(angle)-1, -1); glVertex3f(- cos(angle+angInc), sin(angle+angInc)-1, -1); glEnd(); // vault glNormal3f(-cos(angle+angInc/2),-sin(angle+angInc/2),0); glColor3f(0,0,1); glBegin(GL_POLYGON); glVertex3f( cos(angle) , sin(angle)-1 ,1); // corner glVertex3f( cos(angle) , sin(angle)-1, -1); glVertex3f( cos(angle+angInc), sin(angle+angInc)-1, -1); glEnd(); glBegin(GL_POLYGON); glVertex3f( cos(angle) , sin(angle)-1 ,1); // corner glVertex3f( cos(angle+angInc) , sin(angle+angInc)-1, 1); glVertex3f( cos(angle+angInc), sin(angle+angInc)-1, -1); glEnd(); glNormal3f(cos(angle+angInc/2),-sin(angle+angInc/2),0); glBegin(GL_POLYGON); glVertex3f( - cos(angle) , sin(angle)-1 ,1); // corner glVertex3f( -cos(angle) , sin(angle)-1, -1); glVertex3f( -cos(angle+angInc), sin(angle+angInc)-1, -1); glEnd(); glBegin(GL_POLYGON); glVertex3f( - cos(angle) , sin(angle)-1 ,1); // corner glVertex3f( -cos(angle+angInc) , sin(angle+angInc)-1, 1); glVertex3f( -cos(angle+angInc), sin(angle+angInc)-1, -1); glEnd(); angle += angInc; } }
/* draw method for ant */ static Bool draw_ant(antspotlightstruct *mp, const GLfloat *Material, int mono, int shadow, float ant_step, Bool (*sphere)(float), Bool (*cone)(float)) { float cos1 = cos(ant_step); float cos2 = cos(ant_step + 2 * Pi / 3); float cos3 = cos(ant_step + 4 * Pi / 3); float sin1 = sin(ant_step); float sin2 = sin(ant_step + 2 * Pi / 3); float sin3 = sin(ant_step + 4 * Pi / 3); /* Apparently this is a performance killer on many systems... glEnable(GL_POLYGON_SMOOTH); */ glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mp->mono ? MaterialGray5 : Material); glEnable(GL_CULL_FACE); glPushMatrix(); glScalef(1, 1.3, 1); if(!((*sphere)(0.18))) return False; glScalef(1, 1 / 1.3, 1); glTranslatef(0.00, 0.30, 0.00); if(!((*sphere)(0.2))) return False; glTranslatef(-0.05, 0.17, 0.05); glRotatef(-90, 1, 0, 0); glRotatef(-25, 0, 1, 0); if(!((*cone)(0.05))) return False; glTranslatef(0.00, 0.10, 0.00); if(!((*cone)(0.05))) return False; glRotatef(25, 0, 1, 0); glRotatef(90, 1, 0, 0); glScalef(1, 1.3, 1); glTranslatef(0.15, -0.65, 0.05); if(!((*sphere)(0.25))) return False; glScalef(1, 1 / 1.3, 1); glPopMatrix(); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); /* ANTENNAS */ glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBegin(GL_LINES); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, 0.30, 0.00); glColor3fv(MaterialGray); glVertex3f(0.40, 0.70, 0.40); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, 0.30, 0.00); glColor3fv(MaterialGray); glVertex3f(0.40, 0.70, -0.40); glEnd(); if(!shadow) { glBegin(GL_POINTS); glColor3fv(mp->mono ? MaterialGray6 : MaterialGray5); glVertex3f(0.40, 0.70, 0.40); glVertex3f(0.40, 0.70, -0.40); glEnd(); } /* LEFT-FRONT ARM */ glBegin(GL_LINE_STRIP); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, 0.05, 0.18); glVertex3f(0.35 + 0.05 * cos1, 0.15, 0.25); glColor3fv(MaterialGray); glVertex3f(-0.20 + 0.05 * cos1, 0.25 + 0.1 * sin1, 0.45); glEnd(); /* LEFT-CENTER ARM */ glBegin(GL_LINE_STRIP); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, 0.00, 0.18); glVertex3f(0.35 + 0.05 * cos2, 0.00, 0.25); glColor3fv(MaterialGray); glVertex3f(-0.20 + 0.05 * cos2, 0.00 + 0.1 * sin2, 0.45); glEnd(); /* LEFT-BACK ARM */ glBegin(GL_LINE_STRIP); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, -0.05, 0.18); glVertex3f(0.35 + 0.05 * cos3, -0.15, 0.25); glColor3fv(MaterialGray); glVertex3f(-0.20 + 0.05 * cos3, -0.25 + 0.1 * sin3, 0.45); glEnd(); /* RIGHT-FRONT ARM */ glBegin(GL_LINE_STRIP); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, 0.05, -0.18); glVertex3f(0.35 - 0.05 * sin1, 0.15, -0.25); glColor3fv(MaterialGray); glVertex3f(-0.20 - 0.05 * sin1, 0.25 + 0.1 * cos1, -0.45); glEnd(); /* RIGHT-CENTER ARM */ glBegin(GL_LINE_STRIP); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, 0.00, -0.18); glVertex3f(0.35 - 0.05 * sin2, 0.00, -0.25); glColor3fv(MaterialGray); glVertex3f(-0.20 - 0.05 * sin2, 0.00 + 0.1 * cos2, -0.45); glEnd(); /* RIGHT-BACK ARM */ glBegin(GL_LINE_STRIP); glColor3fv(mp->mono ? MaterialGray5 : Material); glVertex3f(0.00, -0.05, -0.18); glVertex3f(0.35 - 0.05 * sin3, -0.15, -0.25); glColor3fv(MaterialGray); glVertex3f(-0.20 - 0.05 * sin3, -0.25 + 0.1 * cos3, -0.45); glEnd(); if(!shadow) { glBegin(GL_POINTS); glColor3fv(MaterialGray5); glVertex3f(-0.20 + 0.05 * cos1, 0.25 + 0.1 * sin1, 0.45); glVertex3f(-0.20 + 0.05 * cos2, 0.00 + 0.1 * sin2, 0.45); glVertex3f(-0.20 + 0.05 * cos3, -0.25 + 0.1 * sin3, 0.45); glVertex3f(-0.20 - 0.05 * sin1, 0.25 + 0.1 * cos1, -0.45); glVertex3f(-0.20 - 0.05 * sin2, 0.00 + 0.1 * cos2, -0.45); glVertex3f(-0.20 - 0.05 * sin3, -0.25 + 0.1 * cos3, -0.45); glEnd(); } glEnable(GL_LIGHTING); return True; }
void OpenGL::SetMaterial(GLfloat* materialAmbDiffColor) { glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialAmbDiffColor); return; }
void Model::renderMesh(bool bWireframe, bool bLight) { // get the renderer of the model CalRenderer *pCalRenderer; pCalRenderer = m_calModel->getRenderer(); // begin the rendering loop if(!pCalRenderer->beginRendering()) return; // set wireframe mode if necessary if(bWireframe) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); } // set the global OpenGL states glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); // set the lighting mode if necessary if(bLight) { glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); } // we will use vertex arrays, so enable them glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); // get the number of meshes int meshCount; meshCount = pCalRenderer->getMeshCount(); // render all meshes of the model int meshId; for(meshId = 0; meshId < meshCount; meshId++) { // get the number of submeshes int submeshCount; submeshCount = pCalRenderer->getSubmeshCount(meshId); // render all submeshes of the mesh int submeshId; for(submeshId = 0; submeshId < submeshCount; submeshId++) { // select mesh and submesh for further data access if(pCalRenderer->selectMeshSubmesh(meshId, submeshId)) { unsigned char meshColor[4]; GLfloat materialColor[4]; // set the material ambient color pCalRenderer->getAmbientColor(&meshColor[0]); materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f; glMaterialfv(GL_FRONT, GL_AMBIENT, materialColor); // set the material diffuse color pCalRenderer->getDiffuseColor(&meshColor[0]); materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f; glMaterialfv(GL_FRONT, GL_DIFFUSE, materialColor); // set the vertex color if we have no lights if(!bLight) { glColor4fv(materialColor); } // set the material specular color pCalRenderer->getSpecularColor(&meshColor[0]); materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f; glMaterialfv(GL_FRONT, GL_SPECULAR, materialColor); // set the material shininess factor float shininess; shininess = 50.0f; //TODO: pCalRenderer->getShininess(); glMaterialfv(GL_FRONT, GL_SHININESS, &shininess); // get the transformed vertices of the submesh static float meshVertices[30000][3]; int vertexCount; vertexCount = pCalRenderer->getVertices(&meshVertices[0][0]); // get the transformed normals of the submesh static float meshNormals[30000][3]; pCalRenderer->getNormals(&meshNormals[0][0]); // get the texture coordinates of the submesh static float meshTextureCoordinates[30000][2]; int textureCoordinateCount; textureCoordinateCount = pCalRenderer->getTextureCoordinates(0, &meshTextureCoordinates[0][0]); // get the faces of the submesh static CalIndex meshFaces[50000][3]; int faceCount; faceCount = pCalRenderer->getFaces(&meshFaces[0][0]); // set the vertex and normal buffers glVertexPointer(3, GL_FLOAT, 0, &meshVertices[0][0]); glNormalPointer(GL_FLOAT, 0, &meshNormals[0][0]); // set the texture coordinate buffer and state if necessary if((pCalRenderer->getMapCount() > 0) && (textureCoordinateCount > 0)) { glEnable(GL_TEXTURE_2D); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_COLOR_MATERIAL); // set the texture id we stored in the map user data glBindTexture(GL_TEXTURE_2D, (GLuint)pCalRenderer->getMapUserData(0)); // set the texture coordinate buffer glTexCoordPointer(2, GL_FLOAT, 0, &meshTextureCoordinates[0][0]); glColor3f(1.0f, 1.0f, 1.0f); } // draw the submesh if(sizeof(CalIndex)==2) glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_SHORT, &meshFaces[0][0]); else glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_INT, &meshFaces[0][0]); // disable the texture coordinate state if necessary if((pCalRenderer->getMapCount() > 0) && (textureCoordinateCount > 0)) { glDisable(GL_COLOR_MATERIAL); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_2D); } } } } // clear vertex array state glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); // reset the lighting mode if(bLight) { glDisable(GL_LIGHTING); glDisable(GL_LIGHT0); } // reset the global OpenGL states glDisable(GL_DEPTH_TEST); // reset wireframe mode if necessary if(bWireframe) { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); } // end the rendering pCalRenderer->endRendering(); }
bool glWindow::ResetGL () { if (m_resetGLMode == RGM_RECREATEWINDOW) { RecreateWindow (m_fullScreen, m_border, m_width, m_height, m_bpp, m_stencil, m_title, m_allowResizing, m_fitToWorkArea); return true; } else if (m_resetGLMode == RGM_RECREATECONTEXT) { RecreateGLContext (); return true; } // Setup OpenGL defaults. // This should reset as much as possible back to the initial state of OpenGL. // Exceptions: // * Projection matrix is initialised to a perspective transform // End current gl block try { glEnd (); } catch (...) { ; } m_dontPaint = false; // Intialise matrices try { glMatrixMode (GL_PROJECTION); ClearGLMatrix (); } catch (...) { ; } try { glMatrixMode (GL_TEXTURE); ClearGLMatrix (); } catch (...) { ; } try { glMatrixMode (GL_MODELVIEW); ClearGLMatrix (); } catch (...) { ; } // Initialise state int i; try { glColor4f (1, 1, 1, 1); } catch (...) { ; } try { glIndexi (1); } catch (...) { ; } try { glTexCoord4f (0, 0, 0, 1); } catch (...) { ; } try { glNormal3f (0, 0, 1); } catch (...) { ; } // try { glRasterPos4f (0, 0, 0, 1); } catch (...) { ; } try { glEdgeFlag (GL_TRUE); } catch (...) { ; } try { glDisable (GL_VERTEX_ARRAY); } catch (...) { ; } try { glDisable (GL_NORMAL_ARRAY); } catch (...) { ; } try { glDisable (GL_COLOR_ARRAY); } catch (...) { ; } try { glDisable (GL_INDEX_ARRAY); } catch (...) { ; } try { glDisable (GL_TEXTURE_COORD_ARRAY); } catch (...) { ; } try { glDisable (GL_EDGE_FLAG_ARRAY); } catch (...) { ; } try { glDepthRange (0, 1); } catch (...) { ; } try { glDisable (GL_NORMALIZE); } catch (...) { ; } for (i = 0; i < GL_MAX_CLIP_PLANES; i++) try { glDisable (GL_CLIP_PLANE0 + i); } catch (...) { ; } GLfloat fog[] = {0, 0, 0, 0}; try { glFogfv (GL_FOG_COLOR, fog); } catch (...) { ; } try { glFogi (GL_FOG_INDEX, 0); } catch (...) { ; } try { glFogf (GL_FOG_DENSITY, 1.0); } catch (...) { ; } try { glFogf (GL_FOG_START, 0.0); } catch (...) { ; } try { glFogf (GL_FOG_END, 1.0); } catch (...) { ; } try { glFogi (GL_FOG_MODE, GL_EXP); } catch (...) { ; } try { glDisable (GL_FOG); } catch (...) { ; } try { glShadeModel (GL_SMOOTH); } catch (...) { ; } try { glDisable (GL_LIGHTING); } catch (...) { ; } try { glDisable (GL_COLOR_MATERIAL); } catch (...) { ; } try { glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); } catch (...) { ; } GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 }, diffuse[] = { 0.8, 0.8, 0.8, 1.0 }, specular[] = { 0.0, 0.0, 0.0, 1.0 }, emission[] = { 0.0, 0.0, 0.0, 1.0 }, shininess[] = { 0.0 }; try { glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, ambient); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, shininess); } catch (...) { ; } try { glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambient); } catch (...) { ; } try { glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); } catch (...) { ; } try { glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); } catch (...) { ; } GLfloat lambient[] = { 0.0, 0.0, 0.0, 1.0 }, ldiffuse0[] = { 1.0, 1.0, 1.0, 1.0 }, ldiffuse1[] = { 0.0, 0.0, 0.0, 1.0 }, lspecular0[] = { 1.0, 1.0, 1.0, 1.0 }, lspecular1[] = { 0.0, 0.0, 0.0, 1.0 }, lposition[] = { 0.0, 0.0, 1.0, 0.0 }; for (i = 0; i < 8; i++) { try { glLightfv (GL_LIGHT0 + i, GL_AMBIENT, lambient); } catch (...) { ; } try { glLightfv (GL_LIGHT0 + i, GL_DIFFUSE, i == 0 ? ldiffuse0 : ldiffuse1); } catch (...) { ; } try { glLightfv (GL_LIGHT0 + i, GL_SPECULAR, i == 0 ? lspecular0 : lspecular1); } catch (...) { ; } try { glLightfv (GL_LIGHT0 + i, GL_POSITION, lposition); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_SPOT_EXPONENT, 0.0); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, 1.0); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, 0.0); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, 0.0); } catch (...) { ; } try { glDisable (GL_LIGHT0 + i); } catch (...) { ; } } try { glPointSize (1.0); } catch (...) { ; } try { glDisable (GL_POINT_SMOOTH); } catch (...) { ; } try { glLineWidth (1.0); } catch (...) { ; } try { glDisable (GL_LINE_SMOOTH); } catch (...) { ; } try { glLineStipple (1, 0xffff); } catch (...) { ; } try { glDisable (GL_LINE_STIPPLE); } catch (...) { ; } try { glDisable (GL_CULL_FACE); } catch (...) { ; } try { glCullFace (GL_BACK); } catch (...) { ; } try { glFrontFace (GL_CCW); } catch (...) { ; } try { glDisable (GL_POLYGON_SMOOTH); } catch (...) { ; } try { glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); } catch (...) { ; } try { glDisable (GL_TEXTURE_1D); } catch (...) { ; } try { glDisable (GL_TEXTURE_2D); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } catch (...) { ; } GLfloat texBorder[] = {0, 0, 0, 0}; try { glTexParameterfv (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, texBorder); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_T); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_S); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_R); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_Q); } catch (...) { ; } for (i = 0; i < 4; i++) { GLenum coord; switch (i) { case 0: coord = GL_T; break; case 1: coord = GL_S; break; case 2: coord = GL_R; break; case 3: coord = GL_Q; break; } try { glTexGeni (coord, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); } catch (...) { ; } } try { glDisable (GL_SCISSOR_TEST); } catch (...) { ; } try { glDisable (GL_ALPHA_TEST); } catch (...) { ; } try { glAlphaFunc (GL_ALWAYS, 0); } catch (...) { ; } try { glDisable (GL_STENCIL_TEST); } catch (...) { ; } try { glStencilFunc (GL_ALWAYS, 0, 0xffffffff); } catch (...) { ; } try { glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); } catch (...) { ; } try { glDisable (GL_DEPTH_TEST); } catch (...) { ; } try { glDepthFunc (GL_LESS); } catch (...) { ; } try { glDisable (GL_BLEND); } catch (...) { ; } try { glBlendFunc (GL_ONE, GL_ZERO); } catch (...) { ; } try { glDrawBuffer (GL_BACK); } catch (...) { ; } try { glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } catch (...) { ; } try { glDepthMask (GL_TRUE); } catch (...) { ; } try { glClearAccum (0, 0, 0, 0); } catch (...) { ; } try { glClearColor (0, 0, 0, 0); } catch (...) { ; } try { glClearDepth (1); } catch (...) { ; } try { glClearIndex (0); } catch (...) { ; } try { glClearStencil (0); } catch (...) { ; } try { glPixelStorei (GL_PACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; } try { glPixelStorei (GL_PACK_LSB_FIRST, GL_FALSE); } catch (...) { ; } try { glPixelStoref (GL_PACK_ROW_LENGTH, 0); } catch (...) { ; } try { glPixelStoref (GL_PACK_SKIP_PIXELS, 0); } catch (...) { ; } try { glPixelStorei (GL_PACK_ALIGNMENT, 4); } catch (...) { ; } try { glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; } try { glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE); } catch (...) { ; } try { glPixelStoref (GL_UNPACK_ROW_LENGTH, 0); } catch (...) { ; } try { glPixelStoref (GL_UNPACK_SKIP_PIXELS, 0); } catch (...) { ; } try { glPixelStorei (GL_UNPACK_ALIGNMENT, 4); } catch (...) { ; } try { glPixelTransferi (GL_MAP_COLOR, GL_FALSE); } catch (...) { ; } try { glPixelTransferi (GL_MAP_STENCIL, GL_FALSE); } catch (...) { ; } try { glPixelTransferi (GL_INDEX_SHIFT, 0); } catch (...) { ; } try { glPixelTransferi (GL_INDEX_OFFSET, 0); } catch (...) { ; } try { glPixelTransferf (GL_RED_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_GREEN_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_BLUE_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_ALPHA_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_DEPTH_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_RED_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_GREEN_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_BLUE_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_ALPHA_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_DEPTH_BIAS, 0.0); } catch (...) { ; } try { glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_POINT_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_FOG_HINT, GL_DONT_CARE); } catch (...) { ; } // Multitexturing if (ExtensionSupported ("GL_ARB_multitexture")) { // Disable texturing for all texture units int units; try { glGetIntegerv (GL_MAX_TEXTURE_UNITS_ARB, &units); } catch (...) { ; } for (int i = 0; i < units; i++) { if (glActiveTexture != NULL) glActiveTexture (GL_TEXTURE0_ARB + i); try { glDisable (GL_TEXTURE_2D); } catch (...) { ; } try { glDisable (GL_TEXTURE_1D); } catch (...) { ; } if (i == 0) try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } catch (...) { ; } else try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } catch (...) { ; } } if (glActiveTexture != NULL) try { glActiveTexture (GL_TEXTURE0_ARB); } catch (...) { ; } } // Setup OpenGL defaults OpenGLDefaults (); return TRUE; // Initialization Went OK }
void drawNewArm(const float jointParam[][4]) { //glPushMatrix(); float d1 = forwardKinParam[1][3]; // 1 meter float d2 = forwardKinParam[2][3]; float d3 = forwardKinParam[3][3]; float d4=1; GLfloat radius = 0.05; // in centimeters float lenght1=d1-radius ; float lenght2=d2-(2*radius) ; float lenght3=d3-radius ; drawAxis(1.0, ENABLE_AXIS);// draw at the origin glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, ELNAZ_COLOUR); glColor3f(1, 0.5, 0.5); glScalef(radius, radius, radius); glutSolidSphere(3, 50, 50); glPopMatrix(); frame2frame(jointParam[0],0,0); drawAxis(1.0, ENABLE_AXIS); frame2frame(jointParam[1],0,0); glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, ELNAZ_COLOUR); glColor3f(1,0.5,0.5); glScalef(radius, radius, radius); glutSolidSphere (1,50,50); glPopMatrix(); glPushMatrix(); glTranslatef(0, 0, -lenght1 / 2.0); glMaterialfv(GL_FRONT, GL_DIFFUSE, ELNAZ_COLOUR); glScalef(radius, radius, lenght1); glutSolidCube(1); glPopMatrix(); drawAxis(1.0, ENABLE_AXIS); frame2frame(jointParam[2],0,0); glPushMatrix(); glColor3f(1,0.5,0.5); glScalef(radius, radius, radius); glutSolidSphere (1,50,50); glPopMatrix(); drawAxis(1.0, ENABLE_AXIS); glPushMatrix(); glMaterialfv(GL_FRONT, GL_DIFFUSE, ELNAZ_COLOUR); glTranslatef(0, 0, -radius - lenght2 / 2.0); glColor3f(0.5, 1, 0.5); glScalef(radius, radius, lenght2); glutSolidCube(1); glPopMatrix(); frame2frame(jointParam[3],0,0); glPushMatrix(); glTranslatef(0,0,-1*(lenght3/2.0)); glColor3f(0.5,1,0.5); glScalef(radius,radius,lenght3); glutSolidCube(1); glPopMatrix (); drawAxis(1.0, ENABLE_AXIS); //glPopMatrix (); }
void InitGL(void) { GLvoid *image_data; int i, width, height; glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f, (GLfloat) 640 / (GLfloat) 480, 0.1f, 1000.0f); glClearColor(0.7, 0.7, 1, 1); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glCullFace(GL_BACK); glEnable(GL_COLOR_MATERIAL); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_no_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_no_shininess); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Using GL_REPLACE will effectively disable lighting. // The default mode, GL_MODULATE, will use the texture color to // module the shaded material color, so the end result still // contains the shading. //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); // generate texture objects for (i = 0; texture_files[i].filename != NULL; i++) ; texture_names = malloc(i * sizeof(GLuint)); glGenTextures(i, texture_names); glCheckError("glGenTextures"); // create textures from image files GLint texture_internal_format; GLenum texture_format, texture_type; for (i = 0; texture_files[i].filename != NULL; i++) { image_data = (GLvoid *) readppm(texture_files[i].filename, &width, &height); if (image_data) { printf("texture %d (OpenGL name = %d): %s, %d x %d\n", i, texture_names[i], texture_files[i].filename, width, height); if (texture_files[i].contains_transparency) { // Convert the RGB image to RGBA, by replacing // red pixels with transparent ones // Allocate a temporary RGBA image unsigned char *temp_image = (unsigned char*) malloc(width*height*4); unsigned char *input = image_data; unsigned char *output = temp_image; // Convert image to RGBA for (int pix = 0; pix < width*height; pix++) { if (*input == 255 && *(input+1) == 0 && *(input+2) == 0) { // Input pixel is pure red, make output pixel // white color and fully transparent *output++ = 255; *output++ = 255; *output++ = 255; *output++ = 0; // alpha } else { // Copy image color, make fully opaque *output++ = *input; *output++ = *(input + 1); *output++ = *(input + 2); *output++ = 255; } input += 3; } // Replace the RGB image data with the generated RGBA data free(image_data); image_data = temp_image; // This also influences some texture properties texture_internal_format = GL_RGBA8; texture_format = GL_RGBA; texture_type = GL_UNSIGNED_BYTE; } else { texture_internal_format = GL_RGB8; texture_format = GL_RGB; texture_type = GL_UNSIGNED_BYTE; } glBindTexture(GL_TEXTURE_2D, texture_names[i]); glCheckError("glBindTexture"); //http://linux.die.net/man/3/glubuild2dmipmaps //http://linux.die.net/man/3/gltexparameteri //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glCheckError("glTexParameteri"); //glTexImage2D(GL_TEXTURE_2D, 0, texture_internal_format, // width, height, 0, texture_format, texture_type, image_data); gluBuild2DMipmaps(GL_TEXTURE_2D, texture_internal_format, width, height, texture_format, texture_type, image_data); glCheckError("gluBuild2DMipmaps"); //glCheckError("glTexImage2D"); // Free the image data, as OpenGL will have made its internal copy by now free(image_data); } else { perror(texture_files[i].filename); exit(0); } } }
// draw_characterを改変して使ってみる void draw_one_character(s_character *character) { GLfloat color_body[4]; GLfloat color_eye[4] = {0.6, 0.0, 0.0, 1.0}; double pos_base[3] = {-0.27, 0.0, 0.27}; double pos_x, pos_y, pos_z; e_color color; int i; //ここだけ変えた pos_x = character->x; pos_y = character->y; pos_z = character->z; color = character->color; // set color color_body[0] = color_val[color][0]; color_body[1] = color_val[color][1]; color_body[2] = color_val[color][2]; color_body[3] = 1.0; // start drawing an object glPushMatrix(); glMaterialfv(GL_FRONT, GL_AMBIENT, color_body); glMaterialfv(GL_FRONT, GL_DIFFUSE, color_body); glMaterialfv(GL_FRONT, GL_SPECULAR, color_body); glMaterialf(GL_FRONT, GL_SHININESS, 80.0); glTranslatef(pos_x, pos_y, pos_z); // 動いてる向きに回転させる if (character->speed < 0) { glRotatef(90.0f, 0.0f, 0.0f, 1.0f); } else { glRotatef(-90.0f, 0.0f, 0.0f, 1.0f); } // body draw_rectangle(0.5, 0.8, 0.3, 0.0, -0.1, 0.0); // head draw_rectangle(0.3, 0.3, 0.3, 0.0, 0.3, 0.2); for (i = 0; i < 3; i++) { // right // baseleg draw_rectangle(0.4, 0.07, 0.07, -0.2, pos_base[i] - 0.1, 0.0); // endleg draw_rectangle(0.07, 0.07, 0.3, -0.4, pos_base[i] - 0.1, -0.15); // left // baseleg draw_rectangle(0.4, 0.07, 0.07, 0.2, pos_base[i] - 0.1, 0.0); // endleg draw_rectangle(0.07, 0.07, 0.3, 0.4, pos_base[i] - 0.1, -0.15); } glMaterialfv(GL_FRONT, GL_AMBIENT, color_eye); glMaterialfv(GL_FRONT, GL_DIFFUSE, color_eye); glMaterialfv(GL_FRONT, GL_SPECULAR, color_eye); glMaterialf(GL_FRONT, GL_SHININESS, 80.0); // eyes draw_rectangle(0.05, 0.05, 0.05, 0.07, 0.45, 0.25); draw_rectangle(0.05, 0.05, 0.05, -0.07, 0.45, 0.25); // finish drawing an object glPopMatrix(); }
/** * \brief Draw catoms and axes */ void Catoms3DWorld::glDraw() { glPushMatrix(); glDisable(GL_TEXTURE_2D); // draw catoms vector <GlBlock*>::iterator ic=tabGlBlocks.begin(); lock(); while (ic!=tabGlBlocks.end()) { ((Catoms3DGlBlock*)(*ic))->glDraw(objBlock); ic++; } unlock(); glPopMatrix(); // material for the grid walls static const GLfloat white[]={0.8f,0.8f,0.8f,1.0f}, gray[]={0.2f,0.2f,0.2f,1.0f}; glMaterialfv(GL_FRONT,GL_AMBIENT,gray); glMaterialfv(GL_FRONT,GL_DIFFUSE,white); glMaterialfv(GL_FRONT,GL_SPECULAR,white); glMaterialf(GL_FRONT,GL_SHININESS,40.0); lattice->glDraw(); glMaterialfv(GL_FRONT,GL_AMBIENT,gray); glMaterialfv(GL_FRONT,GL_DIFFUSE,white); glMaterialfv(GL_FRONT,GL_SPECULAR,white); glMaterialf(GL_FRONT,GL_SHININESS,40.0); glPushMatrix(); enableTexture(true); glBindTexture(GL_TEXTURE_2D,idTextureGrid); glTranslatef(0,0,lattice->gridScale[2]*(0.5-M_SQRT2_2)); glScalef(lattice->gridSize[0]*lattice->gridScale[0],lattice->gridSize[1]*lattice->gridScale[1],lattice->gridSize[2]*lattice->gridScale[2]*M_SQRT2_2); glBegin(GL_QUADS); // bottom glNormal3f(0,0,1.0f); glTexCoord2f(0,0); glVertex3f(0.0f,0.0f,-0.0f); glTexCoord2f(0.5f*lattice->gridSize[0],0); glVertex3f(1.0f,0.0f,0.0f); glTexCoord2f(0.5f*lattice->gridSize[0],0.5f*lattice->gridSize[1]); glVertex3f(1.0,1.0,0.0f); glTexCoord2f(0,0.5f*lattice->gridSize[1]); glVertex3f(0.0,1.0,0.0f); // top glNormal3f(0,0,-1.0f); glTexCoord2f(0,0); glVertex3f(0.0f,0.0f,1.0f); glTexCoord2f(0.5f*lattice->gridSize[0],0); glVertex3f(0.0,1.0,1.0f); glTexCoord2f(0.5f*lattice->gridSize[0],0.5f*lattice->gridSize[1]); glVertex3f(1.0,1.0,1.0f); glTexCoord2f(0,0.5f*lattice->gridSize[1]); glVertex3f(1.0f,0.0f,1.0f); glEnd(); // draw hexa glBindTexture(GL_TEXTURE_2D,idTextureHexa); glBegin(GL_QUADS); // left glNormal3f(1.0f,0,0); glTexCoord2f(0,0); glVertex3f(0.0f,0.0f,0.0f); glTexCoord2f(lattice->gridSize[1]/3.0f,0); glVertex3f(0.0f,1.0f,0.0f); glTexCoord2f(lattice->gridSize[1]/3.0f,lattice->gridSize[2]/1.5f); glVertex3f(0.0,1.0,1.0f); glTexCoord2f(0,lattice->gridSize[2]/1.5f); glVertex3f(0.0,0.0,1.0f); // right glNormal3f(-1.0f,0,0); glTexCoord2f(0,0); glVertex3f(1.0f,0.0f,0.0f); glTexCoord2f(0,lattice->gridSize[2]/1.5f); glVertex3f(1.0,0.0,1.0f); glTexCoord2f(lattice->gridSize[1]/3.0f,lattice->gridSize[2]/1.5f); glVertex3f(1.0,1.0,1.0f); glTexCoord2f(lattice->gridSize[1]/3.0f,0); glVertex3f(1.0f,1.0f,0.0f); // back glNormal3f(0,-1.0f,0); glTexCoord2f(0,0); glVertex3f(0.0f,1.0f,0.0f); glTexCoord2f(lattice->gridSize[0]/3.0f,0); glVertex3f(1.0f,1.0f,0.0f); glTexCoord2f(lattice->gridSize[0]/3.0f,lattice->gridSize[2]/1.5f); glVertex3f(1.0f,1.0,1.0f); glTexCoord2f(0,lattice->gridSize[2]/1.5f); glVertex3f(0.0,1.0,1.0f); // front glNormal3f(0,1.0,0); glTexCoord2f(0,0); glVertex3f(0.0f,0.0f,0.0f); glTexCoord2f(0,lattice->gridSize[2]/1.5f); glVertex3f(0.0,0.0,1.0f); glTexCoord2f(lattice->gridSize[0]/3.0f,lattice->gridSize[2]/1.5f); glVertex3f(1.0f,0.0,1.0f); glTexCoord2f(lattice->gridSize[0]/3.0f,0); glVertex3f(1.0f,0.0f,0.0f); glEnd(); glPopMatrix(); // draw the axes glPushMatrix(); objRepere->glDraw(); glPopMatrix(); }
///////////////////////////////////////////////////////// // render // ///////////////////////////////////////////////////////// void diffuseRGB :: render(GemState *) { glDisable(GL_COLOR_MATERIAL); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, m_vector); }