Beispiel #1
0
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() ;

}
Beispiel #2
0
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);
}
Beispiel #3
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();
}
Beispiel #5
0
/**
  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
}
Beispiel #6
0
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);
}
Beispiel #7
0
Datei: obj.c Projekt: cjxgm/clabs
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;
}
Beispiel #8
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 );
}
Beispiel #9
0
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;
}
Beispiel #11
0
/* 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);
	}
  }

}
Beispiel #12
0
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
}
Beispiel #13
0
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);
}
Beispiel #16
0
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();

}
Beispiel #17
0
/*----------------------------------------------------------------------------*/
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);
}
Beispiel #18
0
/* ---------------------------------------------------------- */
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;
}
Beispiel #20
0
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;
}
Beispiel #21
0
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);
}
Beispiel #22
0
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
}
Beispiel #23
0
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);
}
Beispiel #24
0
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();
	
}
Beispiel #25
0
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);
}
Beispiel #26
0
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();
}
Beispiel #27
0
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);
}
Beispiel #28
0
//<<<<<<<<<<<<<<<<<<<< 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);
}
Beispiel #29
0
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();

}
Beispiel #30
0
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