void Init(void) { GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 }; GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 }; //GLfloat position[] = { -3.0, 3.0, 3.0, 0.0 }; GLfloat position[] = { 0.0, 0.0, 1.0, 0 }; GLfloat lmodel_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; GLfloat local_view[] = { 0.0 }; /**** set lighting parameters ****/ glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE) ; /* glFrontFace (GL_CW); */ glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_AUTO_NORMAL); glEnable(GL_NORMALIZE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glPixelStorei(GL_PACK_ALIGNMENT,1) ; glPixelStorei(GL_UNPACK_ALIGNMENT,1) ; glShadeModel(GL_SMOOTH) ; g_arcball = new BallData ; Ball_Init(g_arcball); Ball_Place(g_arcball,qOne,0.75); glViewport(0, 0, g_width, g_height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); //glFrustum(-5,5,-5,5,4,100); glOrtho(-6,6,-6,6,-500,500) ; myOpenGLInit() ; }
void initialize(int width, int height) { // select projection matrix glMatrixMode(GL_PROJECTION); // set the viewport glViewport(0, 0, width, height); // set matrix mode glMatrixMode(GL_PROJECTION); // reset projection matrix glLoadIdentity(); GLfloat aspect = (GLfloat) width / height; // set up a perspective projection matrix gluPerspective(45, aspect, 1.0f, 500.0f); // specify which matrix is the current matrix glMatrixMode(GL_MODELVIEW); glShadeModel(GL_SMOOTH); // specify the clear value for the depth buffer glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // specify implementation-specific hints glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); GLfloat amb_light[] = {0.1, 0.1, 0.1, 1.0}; GLfloat diffuse[] = {0.6, 0.6, 0.6, 1}; GLfloat specular[] = {0.7, 0.7, 0.3, 1}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, amb_light); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, specular); glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); glShadeModel(GL_SMOOTH); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glClearColor(0.0, 0.0, 0.0, 1.0); }
void init_viewer_window() { GLfloat Ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; GLfloat Diffuse[] = { 0.8f, 0.8f, 0.8f, 1.0f }; GLfloat Specular[] = { 0.1f, 0.1f, 0.1f, 1.0f }; GLfloat SpecularExp[] = { 50 }; GLfloat Emission[] = { 0.1f, 0.1f, 0.1f, 1.0f }; glMaterialfv(GL_FRONT, GL_AMBIENT, Ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, Diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, Specular); glMaterialfv(GL_FRONT, GL_SHININESS, SpecularExp); glMaterialfv(GL_FRONT, GL_EMISSION, Emission); glMaterialfv(GL_BACK, GL_AMBIENT, Ambient); glMaterialfv(GL_BACK, GL_DIFFUSE, Diffuse); glMaterialfv(GL_BACK, GL_SPECULAR, Specular); glMaterialfv(GL_BACK, GL_SHININESS, SpecularExp); glMaterialfv(GL_BACK, GL_EMISSION, Emission); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glShadeModel(GL_FLAT); glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-0.004,0.004,-0.004,0.004,.01,100.0); glMatrixMode(GL_MODELVIEW); }
void PocketViewer::init() { glClearColor(0.0f,0.0f,0.0f,0.0f); glShadeModel(GL_SMOOTH); glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); glEnable(GL_LIGHTING); glLightModelfv(GL_LIGHT_MODEL_AMBIENT,LightMaterial::BrightLightModelAmb); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); // Lights /*glLightfv(GL_LIGHT0, GL_POSITION, LightMaterial::BrightTopLightPos); glLightfv(GL_LIGHT1, GL_POSITION, LightMaterial::BrightBottomLightPos); glLightfv(GL_LIGHT0, GL_DIFFUSE, LightMaterial::BrightTopLightDif); glLightfv(GL_LIGHT0, GL_AMBIENT, LightMaterial::BrightTopLightAmb); glLightfv(GL_LIGHT0, GL_SPECULAR, LightMaterial::BrightTopLightSpec); glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, LightMaterial::BrightTopLightDir); glLightfv(GL_LIGHT1, GL_DIFFUSE, LightMaterial::BrightBottomLightDif); glLightfv(GL_LIGHT1, GL_AMBIENT, LightMaterial::BrightBottomLightAmb); glLightfv(GL_LIGHT1, GL_SPECULAR, LightMaterial::BrightBottomLightSpec); glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, LightMaterial::BrightBottomLightDir); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1);*/ glEnable(GL_DEPTH_TEST); glDisable(GL_COLOR_MATERIAL); glLineWidth(1.0); glEnable(GL_LINE_SMOOTH); glEnable(GL_POLYGON_SMOOTH); glEnable(GL_POINT_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); // powerDiagram->makeDisplayList(m_processor->alcx->delcx, m_processor->vertexList, complementSpacePD); // help(); }
/** Setup OpenGL here. You should specify your render settings within this method. This method is called once when Qt first retreives the OpenGL context during the creation of this widget. **/ void Lab3Canvas::initializeGL() { m_quadric = gluNewQuadric(); /* Open GL Render Settings */ applyRenderSettings(); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); //set material properties which will be assigned by glColor glCullFace (GL_BACK); glEnable (GL_CULL_FACE); glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); /* Setup Global Lighting */ GLfloat global_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; //OpenGL defaults to 0.2, 0.2, 0.2, 1.0 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1); /* Setup Local Lighting */ GLfloat ambientLight[] = {0.1f, 0.1f, 0.1f, 1.0f}; GLfloat diffuseLight[] = { 1.0f, 1.0f, 1.0, 1.0f }; GLfloat specularLight[] = { 0.5f, 0.5f, 0.5f, 1.0f }; GLfloat position[] = { 2, 2, 2, 1.0f }; glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight); glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight); glLightfv(GL_LIGHT0, GL_POSITION, position); /* Material Properties Code Here*/ GLfloat shiny = 25; GLfloat ambientMat[] = {0.0f, 0.0f, 0.0f, 0.0f}; GLfloat diffuseMat[] = { 0.0f, 0.0f, 0.0, 0.0f }; GLfloat specularMat[] = { 0.5f, 0.5f, 0.5f, 1.0f }; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambientMat); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuseMat); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specularMat); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &shiny); glClearColor(0, 0, 0, 0); //Set the color to clear buffers to }
static void draw_textured_begin(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob) { unsigned char obcol[4]; bool is_tex, solidtex; Mesh *me = ob->data; /* XXX scene->obedit warning */ /* texture draw is abused for mask selection mode, do this so wire draw * with face selection in weight paint is not lit. */ if ((v3d->drawtype <= OB_WIRE) && (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT))) { solidtex = false; Gtexdraw.is_lit = 0; } else if (v3d->drawtype == OB_SOLID || ((ob->mode & OB_MODE_EDIT) && v3d->drawtype != OB_TEXTURE)) { /* draw with default lights in solid draw mode and edit mode */ solidtex = true; Gtexdraw.is_lit = -1; } else { /* draw with lights in the scene otherwise */ solidtex = false; if (v3d->flag2 & V3D_SHADELESS_TEX) Gtexdraw.is_lit = 0; else Gtexdraw.is_lit = GPU_scene_object_lights(scene, ob, v3d->lay, rv3d->viewmat, !rv3d->is_persp); } rgba_float_to_uchar(obcol, ob->col); if (solidtex || v3d->drawtype == OB_TEXTURE) is_tex = true; else is_tex = false; Gtexdraw.ob = ob; Gtexdraw.is_tex = is_tex; Gtexdraw.color_profile = BKE_scene_check_color_management_enabled(scene); Gtexdraw.use_backface_culling = (v3d->flag2 & V3D_BACKFACE_CULLING) != 0; memcpy(Gtexdraw.obcol, obcol, sizeof(obcol)); set_draw_settings_cached(1, NULL, NULL, Gtexdraw); glShadeModel(GL_SMOOTH); glCullFace(GL_BACK); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, (me->flag & ME_TWOSIDED) ? GL_TRUE : GL_FALSE); }
int main(int argc, char * argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(640, 480); glutCreateWindow("Load Wavefront Obj"); glutIdleFunc(&render); glutKeyboardFunc(&key_down); glutKeyboardUpFunc(&key_up); glMatrixMode(GL_PROJECTION); gluPerspective(45, 640.0 / 480.0, 1, 100); glMatrixMode(GL_MODELVIEW); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_CULL_FACE); /* lighting */ { float light_pos[] = { 0, 0, 0, 1 }; float white_light[] = { 1.1, 1.1, 1.1, 1 }; float ambient[] = { 0.4, 0.4, 0.4, 1 }; glLightfv(GL_LIGHT0, GL_POSITION, light_pos); glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light); glLightfv(GL_LIGHT0, GL_SPECULAR, white_light); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); } glClearColor(0, 0, 0, 0); glEnable(GL_DEPTH_TEST); glClearDepth(1.0); camInit(); FILE * fp = fopen("xxx.obj", "r"); go = load_obj(fp); fclose(fp); glutMainLoop(); return 0; }
/* Sets up the light */ void setupLight( ) { glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); glEnable( GL_COLOR_MATERIAL ); glShadeModel( GL_SMOOTH ); glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE ); GLfloat amb [] = {0.5, 0.5, 0.5, 1.0}; glLightModelfv( GL_LIGHT_MODEL_AMBIENT, amb ); /* Set up the bird's materials */ GLfloat spec [] = {0.3, 0.3, 0.3, 1.0}; /* mostly dull specular (feathers!) */ GLfloat diff [] = {0.4, 0.4, 0.4, 1.0}; /* mormal looking ambient/diffuse */ glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, spec ); glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, diff ); }
void init(void) { glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_AMBIENT, lAmbient); glLightfv(GL_LIGHT0, GL_DIFFUSE, lColor); glLightfv(GL_LIGHT0, GL_SPECULAR, lColor); glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR); glClearColor(1.0, 0.0, 1.0, 1.0); teapot_init(load_cube_textures()); //shaders_init(); key_pressed = (bool*)malloc(sizeof(bool) * 256); memset(key_pressed, 0, sizeof(bool) * 256); }
// setup the GLUT library which handles the windows for us int setupGLUT(int *argc, char *argv[]) { glutInit(argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); int winid = glutCreateWindow("OpenSG"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutIdleFunc(display); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(keyboard); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); return winid; }
/* main OpenGL initialization routine */ static void initializeGL(ModeInfo *mi, GLsizei width, GLsizei height) { int style; int mode; reshape_extrusion(mi, width, height); glViewport( 0, 0, width, height ); glEnable(GL_DEPTH_TEST); glDisable (GL_CULL_FACE); glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, True); glShadeModel(GL_SMOOTH); # ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */ MI_IS_WIREFRAME(mi) = 0; # endif if (do_light) SetupLight(); if (MI_IS_WIREFRAME(mi)) { glPolygonMode(GL_FRONT,GL_LINE); glPolygonMode(GL_BACK,GL_LINE); } if (do_texture) { Create_Texture(mi, which_image); glEnable(GL_TEXTURE_2D); /* configure the pipeline */ style = TUBE_JN_CAP; style |= TUBE_CONTOUR_CLOSED; style |= TUBE_NORM_FACET; style |= TUBE_JN_ANGLE; gleSetJoinStyle (style); if (do_texture) { mode = GLE_TEXTURE_ENABLE | GLE_TEXTURE_VERTEX_MODEL_FLAT; glMatrixMode (GL_TEXTURE); glLoadIdentity (); glScalef (0.25, 0.1, 1); glMatrixMode (GL_MODELVIEW); gleTextureMode (mode); } } }
void GLUTInit(int *argc, char **argv) { // Open window glutInit(argc, argv); glutInitWindowPosition(100, 100); glutInitWindowSize(GLUTwindow_width, GLUTwindow_height); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // | GLUT_STENCIL GLUTwindow = glutCreateWindow("KD tree test program"); // Initialize background color glClearColor(200.0/255.0, 200.0/255.0, 200.0/255.0, 1.0); // Initialize lights static GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); static GLfloat light0_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse); glEnable(GL_LIGHT0); static GLfloat light1_diffuse[] = { 0.5, 0.5, 0.5, 1.0 }; glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glEnable(GL_LIGHT1); glEnable(GL_NORMALIZE); glEnable(GL_LIGHTING); // Initialize graphics modes glEnable(GL_DEPTH_TEST); glPointSize(3); // Initialize GLUT callback functions glutDisplayFunc(GLUTRedraw); glutReshapeFunc(GLUTResize); glutKeyboardFunc(GLUTKeyboard); glutSpecialFunc(GLUTSpecial); glutMouseFunc(GLUTMouse); glutMotionFunc(GLUTMotion); // Initialize font #if (RN_OS == RN_WINDOWSNT) int font = glGenLists(256); wglUseFontBitmaps(wglGetCurrentDC(), 0, 256, font); glListBase(font); #endif }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); glutCreateWindow("dinoball (Spaceball demo)"); glutDisplayFunc(redraw); glutMouseFunc(mouse); glutMotionFunc(motion); glutTabletMotionFunc(tablet); glutSpaceballMotionFunc(translate); glutSpaceballRotateFunc(rotate); glutSpaceballButtonFunc(button); glutDialsFunc(dials); glutCreateMenu(controlLights); glutAddMenuEntry("Toggle right light", 1); glutAddMenuEntry("Toggle left light", 2); glutAttachMenu(GLUT_RIGHT_BUTTON); makeDinosaur(); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glMatrixMode(GL_PROJECTION); gluPerspective( /* field of view in degree */ 40.0, /* aspect ratio */ 1.0, /* Z near */ 1.0, /* Z far */ 100.0); glMatrixMode(GL_MODELVIEW); gluLookAt(0.0, 0.0, 30.0, /* eye is at (0,0,30) */ 0.0, 0.0, 0.0, /* center is at (0,0,0) */ 0.0, 1.0, 0.); /* up is in positive Y direction */ glPushMatrix(); /* dummy push so we can pop on model recalc */ glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition); glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor); glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1); glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05); glLightfv(GL_LIGHT1, GL_POSITION, lightOnePosition); glLightfv(GL_LIGHT1, GL_DIFFUSE, lightOneColor); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
int main (int argc, char **argv) { if (argc > 1 ) { voxel_edge_len = atof (argv[1]); printf ("Setting voxel edge length to %g\n", voxel_edge_len); } else { printf ("No voxel length provided. Setting it to %g\n", voxel_edge_len ); } glutInit (&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (750, 750); // TODO : Reference glutCreateWindow (argv[0]); // TODO : Reference init (); /* Set the display function */ glutDisplayFunc (&display); /* Set the reshape function */ glutReshapeFunc (&reshape); /* Set the keyboard function */ glutKeyboardFunc (&keyboard); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv (GL_LIGHT0, GL_POSITION, lightpos); glLightfv (GL_LIGHT0, GL_DIFFUSE, lightcol); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); glMatrixMode(GL_PROJECTION); glOrtho(-50., 50., -50., 50., -50., 50.); glMatrixMode(GL_MODELVIEW); glutMainLoop (); return 0; }
void setLight() { GLfloat light_pos[4] = {-5.0, 20.0, -8.0, 0.0}; GLfloat light_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; GLfloat light_diffuse[] = { 0.8f, 0.8f, 0.8f, 1.0f }; GLfloat light_specular[]= { 0.5f, 0.5f, 0.5f, 1.0f }; // ligar iluminaчуo glEnable(GL_LIGHTING); // ligar e definir fonte de luz 0 glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_pos); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,estado.localViewer); }
void Canvas3D::initializeGL() { // Track the camera settings so we can generate deltas m_oldPosX = settings.cameraPosX; m_oldPosY = settings.cameraPosY; m_oldPosZ = settings.cameraPosZ; m_oldRotU = settings.cameraRotU; m_oldRotV = settings.cameraRotV; m_oldRotN = settings.cameraRotN; // Use a depth buffer and only draw when objects have a depth less than or // equal to the depth present in the buffer. This will make sure the final // buffer will only contain the closest object at each pixel (the depth // buffer starts off filled with the furthest possible distance). glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // Move the polygons back a bit so lines are still drawn even though they are // coplanar with the polygons they came from, which will be drawn before them glEnable(GL_POLYGON_OFFSET_LINE); glPolygonOffset(-1, -1); // Specular reflections will be off without this, since OpenGL calculates // specular highlights using an infinitely far away camera by default, not // the actual location of the camera glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); // TODO: might want to do this for textured scenes // glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); // Hide backfaces so you can tell when triangles are backwards (counter-clockwise // triangles will be visible) glEnable(GL_CULL_FACE); glFrontFace(GL_CCW); // Show all ambient light for the entire scene (not one by default) static float one[] = { 1, 1, 1, 1 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, one); // Calculate the orbiting camera matrices now that the OpenGL context is created. getOrbitingCamera()->updateMatrices(); }
/*----------------------------------------------------------------------------*/ void openglScreenSize(Uint16 width, Uint16 height) { screen_w = width; screen_h = height; glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glFrontFace(GL_CCW); glCullFace(GL_BACK); glDepthFunc(GL_LEQUAL); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); glHint(GL_FOG_HINT, GL_FASTEST); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, TRUE); }
/* ---------------------------------------------------------- */ int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL); glutInitWindowSize(800,800); glutCreateWindow("OpenGl application"); /* Register GLUT callbacks. */ glutDisplayFunc(redraw); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); glMatrixMode(GL_PROJECTION); gluPerspective ( 40.0,/* field of view in degree */ 1.0,/* aspect ratio *//* Z near */ 1.0, 100.0/* Z far */ ); glMatrixMode(GL_MODELVIEW); gluLookAt( 0.0, 0.0, 5.0, /* eye */ 0.0, 0.0, 0.0, /* center */ 1.0, 0.0, 0.0); /* up is in positive Y direction */ { GLfloat color[4]={1,0,0,1}; GLfloat colorwhite [] = {1.0f, 1.0f, 1.0f, 1.0f}; GLfloat colorgray [] = {0.2f, 0.2f, 0.2f, 1.0f}; glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); glLightfv(GL_LIGHT0, GL_DIFFUSE, colorgray );glEnable (GL_LIGHT0); glLightfv(GL_LIGHT1, GL_DIFFUSE, colorwhite);glEnable (GL_LIGHT1); glEnable(GL_LIGHTING); } glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
bool MtlBlinnGL3D::Activate(RenderContextGL3D &rc) { if (rc.ShadePath == SP_FixedFunction) { MtlBlinnData3D *mpd = (MtlBlinnData3D *) MtlData; Vector4f diffuse = mpd->Opacity * mpd->Diffuse; glColor4fv(diffuse.V); if (rc.DoLighting) { Vector4f ambient = mpd->Opacity * mpd->Diffuse; Vector4f specular = mpd->Opacity * mpd->Specular; Vector4f emission = Color4f(0.0f, 0.0f, 0.0f, 0.0f); float32 specularExp = GLTools.LimitSpecularExponent(mpd->SpecularExponent); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient.V); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse.V); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.V); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission.V); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, specularExp); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, UseTwoSidedLighting); } } else if (rc.ShadePath == SP_Cg) { //ActivateManagedParams(rc); // the MaterialGL base class will call this by default BlinnCg *sn = (BlinnCg *) rc.CgShader->GetShadeNode(this); MtlBlinnData3D *data = (MtlBlinnData3D *) MtlData; data->Specular.A = 1.0f; sn->Diffuse.Set(data->Opacity * data->Diffuse); sn->Specular.Set(data->Opacity * data->Specular); sn->SpecularIntensity.Set(data->SpecularIntensity); sn->SpecularExponent.Set(data->SpecularExponent); } return true; }
void init_properties() { /* Lighting and material properties */ /* sun light */ glLightfv(SUNLIGHT, GL_DIFFUSE, sunlight_diffuse); glLightfv(SUNLIGHT, GL_AMBIENT, sunlight_ambient); glEnable(SUNLIGHT); /* eye light */ glLightfv(EYELIGHT, GL_DIFFUSE, eyelight_diffuse); glLightf(EYELIGHT, GL_SPOT_CUTOFF, 8.0); glLightf(EYELIGHT, GL_QUADRATIC_ATTENUATION, 0.03f); glEnable(EYELIGHT); /* object light */ glLightfv(OBJLIGHT, GL_DIFFUSE, objlight_diffuse); glLightfv(OBJLIGHT, GL_SPECULAR, objlight_specular); glEnable(OBJLIGHT); /* material properties */ /* YOUR CODE HERE * Your surfaces will not interact with your light until you * specify how the material of the surface reflects light. * Use glMaterial*() call to set the diffuse and specular * responses of the material (use the values defined above, * mat_diffuse, mat_ambient, mat_specular, mat_shininess). * You are welcome to experiment with different values for the settings. */ glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); //material /* specularity computed taking into account eye location * as opposed to just assuming that view is parallel to z */ glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glEnable(GL_LIGHTING); return; }
void ModelShow::initializeGL() { glEnable(GL_DEPTH); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); //glFrontFace(GL_CW); glFrontFace(GL_CCW); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE); glEnable(GL_NORMALIZE); glDepthFunc(GL_LEQUAL); glEnable(GL_COLOR_MATERIAL); glPolygonMode(GL_FRONT_AND_BACK,renderMode); glShadeModel(GL_SMOOTH); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); static GLfloat lightPosition[4]={0.5,5.0,7.0,1.0 }; glLightfv(GL_LIGHT0,GL_POSITION,lightPosition); }
void GLWidget::initializeGL() { int i; QImage buf(256, 256, QImage::Format_RGB32); GLfloat whiteDir[4] = {2.0, 2.0, 2.0, 1.0}; GLfloat whiteAmb[4] = {1.0, 1.0, 1.0, 1.0}; GLfloat lightPos[4] = {30.0, 30.0, 30.0, 1.0}; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, whiteAmb); glMaterialfv(GL_FRONT, GL_DIFFUSE, whiteDir); glMaterialfv(GL_FRONT, GL_SPECULAR, whiteDir); glMaterialf(GL_FRONT, GL_SHININESS, 20.0); glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteDir); // enable diffuse glLightfv(GL_LIGHT0, GL_SPECULAR, whiteDir); // enable specular glLightfv(GL_LIGHT0, GL_POSITION, lightPos); glShadeModel( GL_SMOOTH ); // Set up the textures //QImage buf( 256, 256, 32 ); for (i=0; i<6; i++) { makeSpots(i, &buf); tex[i] = QGLWidget::convertToGLFormat( buf ); // flipped 32bit RGBA } glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glEnable( GL_TEXTURE_2D ); // Set up various other stuff glClearColor( 0.5, 1.0, 0.75, 0.0 ); // Let OpenGL clear to black glEnable( GL_CULL_FACE ); // don't need Z testing for convex objects glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ); // Make the object display list object = makeDice( ); // Generate an OpenGL display list }
void do_lights(){ float light0_ambient[] = {0.0,0.0,0.0,0.0}; float light0_diffuse[] = {1.0,1.0,1.0,0.0}; float light0_specular[] = {1.0,1.0,1.0,0.0}; float light0_position[] = {1.5,2.0,2.0,1.0}; float light0_direction[] = {-1.5,-2.0,-2.0,1.0}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT,light0_ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,1); glLightfv(GL_LIGHT0,GL_AMBIENT,light0_ambient); glLightfv(GL_LIGHT0,GL_DIFFUSE,light0_diffuse); glLightfv(GL_LIGHT0,GL_SPECULAR,light0_specular); glLightfv(GL_LIGHT0,GL_POSITION,light0_position); glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,light0_direction); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); }
void Viewport::glInit() { // Esegue dei comandi opengl per rendere attive le impostazioni // nella struct RenderMode. makeCurrent(); (RenderMode.Texture) ? glEnable(GL_TEXTURE_2D) : glDisable(GL_TEXTURE_2D); if (RenderMode.Solid) { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); } else { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); glEnable(GL_COLOR_MATERIAL); //glColor3ub(255,255,255); } (RenderMode.Cullface) ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE); (RenderMode.DepthTest) ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST); glClearColor(RenderMode.ClearColor[0], RenderMode.ClearColor[1], RenderMode.ClearColor[2], RenderMode.ClearColor[3]); glEnable(GL_POINT_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST); glPointSize(5.0f); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //glBlendFunc(GL_SRC_ALPHA, GL_ONE); glAlphaFunc(GL_GEQUAL, 0.5f); makeNonCurrent(); }
static void draw_init_lights(void){ float mat_specular[] = {1.0,1.0,1.0,1.0}; float mat_shining[] = {50.0}; float light_position[] = {5,5,10.0,0.0}; float light_color[] = {1.0,1.0,1.0,1.0}; float light_ambiant[] = {0.1,0.1,0.1,1.0}; glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular); glMaterialfv(GL_FRONT,GL_SHININESS,mat_shining); glMaterialfv(GL_BACK,GL_SPECULAR,mat_specular); glMaterialfv(GL_BACK,GL_SHININESS,mat_shining); glLightfv(GL_LIGHT0,GL_POSITION,light_position); glLightfv(GL_LIGHT0,GL_DIFFUSE,light_color); glLightfv(GL_LIGHT0,GL_SPECULAR,light_color); glLightModelfv(GL_LIGHT_MODEL_AMBIENT,light_ambiant); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glShadeModel(GL_FLAT); }
void init() { glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightModelfv(GL_LIGHT_MODEL_AMBIENT,global_ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glLightfv(GL_LIGHT0,GL_AMBIENT, dir_ambient); glLightfv(GL_LIGHT0,GL_DIFFUSE, dir_diffuse); glLightfv(GL_LIGHT0,GL_SPECULAR, dir_specular); glLightfv(GL_LIGHT0,GL_POSITION,dir_position); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular); glMateriali(GL_FRONT,GL_SHININESS,30); glEnable(GL_NORMALIZE); glNewList(HILL,GL_COMPILE); for(float x = -50; x < 50; x+=0.5f) { for(float z = -50; z < 50; z+=0.5f) { glColor3f(0,1,0); glBegin(GL_QUADS); glVertex3f(x,-alfa*(pow(x,2)+pow(z,2)),z); glVertex3f(x,-alfa*(pow(x,2)+pow(z+0.5,2)),z+0.5); glVertex3f(x+0.5,-alfa*(pow(x+0.5,2)+pow(z+0.5,2)),z+0.5); glVertex3f(x+0.5,-alfa*(pow(x+0.5,2)+pow(z,2)),z); glEnd(); } } glEndList(); glNewList(CHAIN,GL_COMPILE); glPushMatrix(); glColor3f(0.5,0.5,0.5); glutSolidTorus(0.5,2,60,60); glPopMatrix(); glEndList(); }
void init() { glEnable(GL_DEPTH_TEST); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_FALSE); glEnable(GL_LIGHTING); GLfloat globalAmbient[ ] = { 1.00, 1.00, 1.00, 0.0 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbient); glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE, mat_ambient_diffuse); glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular); glMaterialf(GL_FRONT,GL_SHININESS,mat_shininess); glClearColor(0.0,0.0,0.0,0.0); glutCreateMenu(menu); glutAddMenuEntry("pause/unpause (p)", 1); glutAddMenuEntry("restart game (r)", 2); glutAddMenuEntry("quit", 0); glutAttachMenu(GLUT_RIGHT_BUTTON); }
//<<<<<<<<<<<<<<<<<<<< setLight >>>>>>>>>>>>>>>>>>>>>>>>>>>> void setLight(void) { // set the light source properties GLfloat light0_position[] = { (6.4 + 2*0.04)/2, (5.64 + 0.04 + 2), (9.75 + 2*0.04)/2, 1.0f}; glLightfv(GL_LIGHT0, GL_POSITION, light0_position); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); // set the light source properties (white) //GLfloat lightWhite_ambient[] = {0.5, 0.5, 0.5, 1.0f}; glLightfv(GL_LIGHT0, GL_AMBIENT, lightWhite_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, lightWhite_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, lightWhite_specular); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); }
void init() { glClearColor (0.7f, 0.7f, 1.0f, 0.0f); // set a light model to TWO_SIDE //glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,1); // the default light model is TWO_SIDE = 0 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,0); // enable lighting glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); // enable the manipulation of the diffuse material component by glColor(); glEnable(GL_COLOR_MATERIAL); moebius_list(); }
int main(int argc, char** argv) { int maxtex; glEnable(GL_LIGHTING); // omogućava osvjetljavanje glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); glEnable(GL_LIGHT0); // uključuje svjetlo 0 ucitajPPM(&slika0, "foi_logo.ppm"); ucitajPPM(&slika1, "metal.ppm"); glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(640, 480); glutInitWindowPosition(0, 0); glutCreateWindow(argv[0]); printf("\nVerzija OpenGL-a: %s\n", glGetString(GL_VERSION)); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtex); printf("Maksimalna velicina teksture: %d\n", maxtex); glClearColor (0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); // alokacija teksturnih objekata - openGL vraća broj svake alocirane teksture printf("\nprije: tekstura[0] = %d\n", tekstura[0]); printf("prije: tekstura[1] = %d\n", tekstura[1]); glGenTextures(NTEX, tekstura); printf("poziv: glGenTextures()\n"); printf("poslije: tekstura[0] = %d\n", tekstura[0]); printf("poslije: tekstura[1] = %d\n", tekstura[1]); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); pripremiTex0(); pripremiTex1(); glutDisplayFunc(iscrtaj); glutReshapeFunc(skaliraj); glutKeyboardFunc(tipka); glutIdleFunc(rotiraj); glutMainLoop(); return 0; } // main