void menu(int value)
{
switch( value )
{
case LIGHT_ONE:
lightOne();
break;
case LIGHT_TWO:
lightTwo();
break;
case FLAT_SHADING:
glShadeModel( GL_FLAT );
break;
case SMOOTH_SHADING:
glShadeModel( GL_SMOOTH );
break;
case PHONG_2:
exponent = 2;
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, exponent);
break;
case PHONG_8:
exponent = 8;
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, exponent);
break;
case PHONG_16:
exponent = 16;
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, exponent);
break;
case PHONG_64:
exponent = 64;
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, exponent);
break;
default:
break;
}
// you would want to redraw now
glutPostRedisplay();
}
/* There's a disc with a hole in it around the screen, to act as a mask
preventing slightly off-screen bogies from showing up. This clips 'em.
*/
static int
draw_table (ModeInfo *mi)
{
/*sonar_configuration *sp = &sps[MI_SCREEN(mi)];*/
int wire = MI_IS_WIREFRAME(mi);
int polys = 0;
int i;
int th_steps = 36 * 4; /* same as in draw_screen */
static const GLfloat color[4] = {0.0, 0.0, 0.0, 1.0};
static const GLfloat text[4] = {0.15, 0.15, 0.15, 1.0};
static const GLfloat spec[4] = {0.0, 0.0, 0.0, 1.0};
static const GLfloat shiny = 0.0;
if (wire) return 0;
glPushAttrib (GL_ENABLE_BIT);
glDisable (GL_TEXTURE_2D);
glMaterialfv (GL_FRONT, GL_SPECULAR, spec);
glMateriali (GL_FRONT, GL_SHININESS, shiny);
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
glFrontFace (GL_CCW);
glBegin(wire ? GL_LINES : GL_QUAD_STRIP);
glNormal3f (0, 0, 1);
for (i = 0; i <= th_steps; i++)
{
double a = M_PI * 2 * i / th_steps;
double x = cos(a);
double y = sin(a);
glVertex3f (x, y, 0);
glVertex3f (x*10, y*10, 0);
polys++;
}
glEnd();
glPopAttrib();
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, text);
glTranslatef (0, 0, 0.01);
for (i = 0; i < 360; i += 10)
{
char buf[10];
GLfloat a = M_PI/2 - (i / 180.0 * M_PI);
sprintf (buf, "%d", i);
polys += draw_text (mi, buf, 1.07, a, 0, 10.0);
}
return polys;
}
void Mesh::draw() const {
// --- TODO: Rewrite - way to many state changes...
glPushMatrix();
glTranslatef( startBase.x(), startBase.y(), startBase.z() );
GLfloat col[4] = {0.0f, 1.0f, 1.0f, 0.1f} ;
glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, col );
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
Vector3f O(0,0,0);
Vector3f end = endBase - startBase;
glEnable (GL_LIGHTING);
glDisable(GL_CULL_FACE); // TODO: do we need this?
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GLfloat c3[4] = {0.3f, 0.3f, 0.3f, 0.5f};
glMaterialfv( GL_FRONT, GL_SPECULAR, c3 );
glMateriali(GL_FRONT, GL_SHININESS, 127);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glBegin( GL_QUADS );
glColor4fv(primaryColor);
GLfloat secondaryColor[4] = {oldRgb[0], oldRgb[1], oldRgb[2], oldAlpha};
//vertex4n(O, startDir1,startDir2+startDir1,startDir2);
Vector3f c1(startDir1*0.5f+startDir2*0.5f);
Vector3f c2(end+endDir1*0.5f+endDir2*0.5f);
vertex4(primaryColor, c1, O, startDir1, secondaryColor,c2, end+endDir1,end,false);
vertex4(primaryColor,c1, O, startDir2, secondaryColor,c2, end+endDir2,end,false);
vertex4(primaryColor,c1, startDir1, startDir1+startDir2,secondaryColor,c2, end+endDir1+endDir2, end+endDir1,false);
vertex4(primaryColor,c1, startDir2, startDir1+startDir2,secondaryColor,c2, end+endDir1+endDir2, end+endDir2,false);
//vertex4n(O+end, endDir1+end,endDir2+endDir1+end,endDir2+end);
glEnd();
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();
};
//////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering
// context.
void SetupRC()
{
int iSphere;
// Calculate shadow matrix
M3DVector3f vPoints[3] = {{ 0.0f, -0.4f, 0.0f },
{ 10.0f, -0.4f, 0.0f },
{ 5.0f, -0.4f, -5.0f }};
// Grayish background
glClearColor(fLowLight[0], fLowLight[1], fLowLight[2], fLowLight[3]);
// Cull backs of polygons
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Setup light parameters
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, fNoLight);
glLightfv(GL_LIGHT0, GL_AMBIENT, fLowLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, fBrightLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, fBrightLight);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// Get the plane equation from three points on the ground
M3DVector4f vPlaneEquation;
m3dGetPlaneEquation(vPlaneEquation, vPoints[0], vPoints[1], vPoints[2]);
// Calculate projection matrix to draw shadow on the ground
m3dMakePlanarShadowMatrix(mShadowMatrix, vPlaneEquation, fLightPos);
// Mostly use material tracking
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMateriali(GL_FRONT, GL_SHININESS, 128);
// Randomly place the sphere inhabitants
for(iSphere = 0; iSphere < NUM_SPHERES; iSphere++)
{
spheres[iSphere].SetOrigin((float)((rand() % 400) - 200) * 0.1f, 0.0f,
(float)((rand() % 400) - 200) * 0.1f);
}
glEnable(GL_MULTISAMPLE); // This is actually on by default
}
void GPU_simple_shader_colors(const float diffuse[3], const float specular[3],
int shininess, float alpha)
{
float gl_diffuse[4], gl_specular[4];
copy_v3_v3(gl_diffuse, diffuse);
gl_diffuse[3] = alpha;
copy_v3_v3(gl_specular, specular);
gl_specular[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, gl_diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, gl_specular);
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, CLAMPIS(shininess, 1, 128));
}
// Define brilho, fontes de luz e reflectancia
void DefineLuz(void) {
GLfloat LuzAmbiente[] = {0.24725f, 0.1995f, 0.07f } ;
GLfloat LuzDifusa[] = {0.75164f, 0.60648f, 0.22648f, 1.0f };
GLfloat LuzEspecular[] = {0.626281f, 0.555802f, 0.366065f, 1.0f };
GLfloat PosicaoLuz0[] = {-40.0f,-40.0f, 100.0f, 1.0f };
GLfloat PosicaoLuz1[] = { 40.0f, 40.0f, 100.0f, 1.0f };
GLfloat Especularidade[] = {1.0f, 1.0f, 1.0f, 1.0f };
// Fonte de Luz 0
glEnable ( GL_COLOR_MATERIAL );
glEnable(GL_LIGHTING);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LuzAmbiente);
glLightfv(GL_LIGHT0, GL_AMBIENT, LuzAmbiente);
glLightfv(GL_LIGHT0, GL_DIFFUSE, LuzDifusa );
glLightfv(GL_LIGHT0, GL_SPECULAR, LuzEspecular );
glLightfv(GL_LIGHT0, GL_POSITION, PosicaoLuz0 );
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT,GL_SPECULAR, Especularidade);
glMateriali(GL_FRONT,GL_SHININESS,51);
// Fonte de Luz 1
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LuzAmbiente);
glLightfv(GL_LIGHT1, GL_AMBIENT, LuzAmbiente);
glLightfv(GL_LIGHT1, GL_DIFFUSE, LuzDifusa );
glLightfv(GL_LIGHT1, GL_SPECULAR, LuzEspecular );
glLightfv(GL_LIGHT1, GL_POSITION, PosicaoLuz1 );
glEnable(GL_LIGHT1);
glEnable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT,GL_SPECULAR, Especularidade);
glMateriali(GL_FRONT,GL_SHININESS,20);
}
//////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering
// context.
void SetupRC()
{
int iSphere;
// Calculate shadow matrix
GLTVector3 vPoints[3] = {{ 0.0f, -0.4f, 0.0f },
{ 10.0f, -0.4f, 0.0f },
{ 5.0f, -0.4f, -5.0f }};
// Grayish background
glClearColor(fLowLight[0], fLowLight[1], fLowLight[2], fLowLight[3]);
// Cull backs of polygons
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Setup light parameters
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, fNoLight);
glLightfv(GL_LIGHT0, GL_AMBIENT, fLowLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, fBrightLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, fBrightLight);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
gltMakeShadowMatrix(vPoints, fLightPos, mShadowMatrix);
// Mostly use material tracking
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMateriali(GL_FRONT, GL_SHININESS, 128);
gltInitFrame(&frameCamera); // Initialize the camera
// Randomly place the sphere inhabitants
for(iSphere = 0; iSphere < NUM_SPHERES; iSphere++)
{
gltInitFrame(&spheres[iSphere]); // Initialize the frame
// Pick a random location between -20 and 20 at .1 increments
spheres[iSphere].vLocation[0] = (float)((rand() % 400) - 200) * 0.1f;
spheres[iSphere].vLocation[1] = 0.0f;
spheres[iSphere].vLocation[2] = (float)((rand() % 400) - 200) * 0.1f;
}
}
void Model::setMaterial(Material mtl) const {
float diff[4];
float spec[4];
float amb[4];
int specExp = ((int)mtl.getSpecularExponent() >= 0) ? (int)mtl.getSpecularExponent() : 0;
mtl.getDiffuseColor().convert(diff);
mtl.getSpecularColor().convert(spec);
mtl.getAmbientColor().convert(amb);
glMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
glMateriali(GL_FRONT, GL_SHININESS, specExp);
glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
mtl.getTexture().apply();
}
void SetOpenGlDefaultMaterial()
{
glm::vec4 ambient( 0.2, 0.2, 0.2, 1.0 );
glm::vec4 specular( 0.0, 0.0, 0.0, 1.0 );
glm::vec4 emissive( 0.0, 0.0, 0.0, 1.0 );
glm::vec4 diffuse( 0.0, 0.0, 0.0, 1.0 );
GLint shininess_value = 0;
glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
glMateriali ( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value );
glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.x );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.x );
glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.x );
glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.x );
}
void PainelVisualizacaoBarragemOpenGL::initializeGL(){
qglClearColor(Qt::white);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
GLfloat luzAmbiente[4]={0.2,0.2,0.2,1.0};
GLfloat luzDifusa[4]={0.7,0.7,0.7,1.0}; // "cor"
GLfloat luzEspecular[4]={1.0, 1.0, 1.0, 1.0};// "brilho"
GLfloat posicaoLuz[4]={-700.0, 700.0, 700.0, 1.0};
// Capacidade de brilho do material
GLfloat especularidade[4]={1.0,1.0,1.0,1.0};
GLint especMaterial = 60;
// Especifica que a cor de fundo da janela será preta
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
// Habilita o modelo de colorização de Gouraud
glShadeModel(GL_SMOOTH);
// Define a refletância do material
glMaterialfv(GL_FRONT,GL_SPECULAR, especularidade);
// Define a concentração do brilho
glMateriali(GL_FRONT,GL_SHININESS,especMaterial);
// Ativa o uso da luz ambiente
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, luzAmbiente);
// Define os parâmetros da luz de número 0
glLightfv(GL_LIGHT0, GL_AMBIENT, luzAmbiente);
glLightfv(GL_LIGHT0, GL_DIFFUSE, luzDifusa );
glLightfv(GL_LIGHT0, GL_SPECULAR, luzEspecular );
glLightfv(GL_LIGHT0, GL_POSITION, posicaoLuz );
// Habilita a definição da cor do material a partir da cor corrente
glEnable(GL_COLOR_MATERIAL);
//Habilita o uso de iluminação
glEnable(GL_LIGHTING);
// Habilita a luz de número 0
glEnable(GL_LIGHT0);
// Habilita o depth-buffering
glEnable(GL_DEPTH_TEST);
}
void glass(GLUquadricObj *quadObj)
{
glPushAttrib(GL_COLOR_MATERIAL);
GLfloat spec[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glVer
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 128);
glColor4f(1, 0.7, 1, 0.3);
gluDisk(quadObj, 0, rTop, 50, 50);
glPopAttrib();
}
App::App(int* argc, char** argv) : width(800), height(800), bullet(shadow),
lightpos({ 0, -200, 0, 1} ),lightpos2({ 0, 50, 0, 1 }){
glutInit(argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(width, height);
glutInitWindowPosition(0, 0);
glutCreateWindow("Program OpenGL");
glutDisplayFunc(DisplayFrameCallback);
glutIdleFunc(NextFrameCallback);
glewInit();
glutKeyboardFunc(KeyDownCallback);
glutKeyboardUpFunc(KeyUpCallback);
glutSpecialFunc(KeySpecialDownCallback);
glutSpecialUpFunc(KeySpecialUpCallback);
glutMouseFunc(MouseFuncCallback);
ResetPointer();
glutSetCursor(GLUT_CURSOR_NONE);
glutPassiveMotionFunc(MotionFuncCallback);
GLfloat ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f };
GLfloat diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glMaterialfv(GL_LIGHT0, GL_AMBIENT, ambient);
glMaterialfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glMaterialfv(GL_LIGHT0, GL_SPECULAR, specular);
glMateriali(GL_FRONT, GL_SHININESS, 50);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glShadeModel(GL_SMOOTH);
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
bullet.AddLevel();
LoadTexture(0, "bricks.bmp");
LoadTexture(1, "ntex.bmp");
}
void BulletOpenGLApplication::Initialize() {
// this function is called inside glutmain() after
// creating the window, but before handing control
// to FreeGLUT
// create some floats for our ambient, diffuse, specular and position
GLfloat ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; // dark grey
GLfloat diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // white
GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // white
GLfloat position[] = { 5.0f, 10.0f, 1.0f, 0.0f };
// set the ambient, diffuse, specular and position for LIGHT0
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHTING); // enables lighting
glEnable(GL_LIGHT0); // enables the 0th light
glEnable(GL_COLOR_MATERIAL); // colors materials when lighting is enabled
// enable specular lighting via materials
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMateriali(GL_FRONT, GL_SHININESS, 15);
// enable smooth shading
glShadeModel(GL_SMOOTH);
// enable depth testing to be 'less than'
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// set the backbuffer clearing color to a lightish blue
glClearColor(0.6, 0.65, 0.85, 0);
// initialize the physics system
InitializePhysics();
// create the debug drawer
m_pDebugDrawer = new DebugDrawer();
// set the initial debug level to 0
m_pDebugDrawer->setDebugMode(0);
// add the debug drawer to the world
m_pWorld->setDebugDrawer(m_pDebugDrawer);
}
void CocktailCupVBO::draw(){
float spec[]={0.33333,0.33333,0.33333,1.0} ;
glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE, cinzentoAlphaCopo);
glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,spec);
glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,128);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPushMatrix();
glTranslatef(0, (alt/2)-(2*rad/3), 0);
glRotatef(180, 1, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER,buffers[0]);
glVertexPointer(3,GL_FLOAT,0,0);
glBindBuffer(GL_ARRAY_BUFFER,buffers[1]);
glNormalPointer(GL_FLOAT,0,0);
glBindBuffer(GL_ARRAY_BUFFER,buffers[2]);
glTexCoordPointer(2,GL_FLOAT,0,0);
glBindTexture(GL_TEXTURE_2D, id_textura) ;
glDrawElements(GL_TRIANGLES, nrIndex ,GL_UNSIGNED_INT, aIndex);
/* Unbind da textura */
glBindTexture(GL_TEXTURE_2D, 0) ;
glPopMatrix();
glPushMatrix();
glTranslatef(0,alt/2/4, 0);
cylinder->draw();
glPopMatrix();
glPushMatrix();
cone->draw();
glPopMatrix();
glPushMatrix();
cyl->draw();
glPopMatrix();
glDisable(GL_BLEND);
reiniciaMaterial();
}
void
illumination(void)
{
/* Iluminação */
GLfloat ambient [4] = {0.2, 0.2, 0.2, 1.0};
GLfloat diffuse [4] = {0.7, 0.7, 0.7, 1.0};
GLfloat specular [4] = {0.8, 0.8, 0.8, 1.0};
GLfloat position [4] = { 0, 0, -1, 1.0};
GLfloat specularity[4] = {1.0, 1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_SPECULAR, specularity);
glMateriali(GL_FRONT, GL_SHININESS, 60);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_POSITION, position);
}
void GarrafaWhisky:: desenhar(){
static float cor[]={0.4, 0.25, 0.09};
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,cor);
glMaterialfv(GL_FRONT,GL_SPECULAR,white);
glMateriali(GL_FRONT,GL_SHININESS,82);
glPushMatrix();
glTranslatef(0,altura*0.5,0);
glPushMatrix();
glScalef(comprimento,altura,largura);
cubo->desenhar();
glPopMatrix();
glPushMatrix();
glTranslatef(0,altura*0.5+0.15*tamanho,0);
c1->desenhar();
glPopMatrix();
glPopMatrix();
}
void Init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
//glEnable(GL_CULL_FACE);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
glMateriali(GL_FRONT, GL_SHININESS,50);
/*GLfloat fLowLight[] ={0,0,0,0};
glEnable(GL_FOG); glFogfv(GL_FOG_COLOR, fLowLight);
glFogf(GL_FOG_START, 5.0f);
glFogf(GL_FOG_END, 50.0f);
glFogi(GL_FOG_MODE, GL_LINEAR);*/
sky.SkyboxTextures((char*)"Textures/Skybox/sp3");
sky.SetColor(0.8f, 0.8f, 0.8f, 1.0);
Textures.CreateTextures(4);
Textures.AddTexture((char*)"Textures/Stone.tga");
Textures.AddTexture((char*)"Textures/Brick.tga");
Textures.AddTexture((char*)"Textures/chrome.tga");
Textures.AddTexture((char*)"Textures/gold.tga");
model.LoadFile((char*)"Models/Watchdog/watchdog2.obj");
p.LoadFile((char*)"Models/plane.obj");
Rocks.LoadFile((char*)"Models/Objs/rocks.obj");
Shad.CreateShader();
Shad.LoadShader((char*)"Shaders/Texture2.vs",GL_VERTEX_SHADER);
Shad.LoadShader((char*)"Shaders/Texture2.fs",GL_FRAGMENT_SHADER);
Shad.CompileShader();
}
void light() {
//glTexEnvi(GL_MODULATE);
if (lighting) glEnable(GL_LIGHTING);
// Create a "sunlight"
GLfloat sun[] = {1.0, 1.0, 1.0, 1.0f};
glLightfv(GL_LIGHT0, GL_DIFFUSE, sun);
glLightfv(GL_LIGHT0, GL_SPECULAR, sun);
GLfloat lightPosition[] = {0.5f, 0.75f, 0.75f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
// Material Settings
GLfloat allLight[] = {1.0f, 1.0f, 1.0f, 1.0f};
// turn on full specular and color by default in material
glMateriali(GL_FRONT, GL_SHININESS, 64);
glMaterialfv(GL_FRONT, GL_SPECULAR, allLight);
glMaterialfv(GL_FRONT, GL_DIFFUSE, allLight);
glMaterialfv(GL_FRONT, GL_AMBIENT, allLight);
glEnable(GL_LIGHT0);
if(fog) {
// Enable and Set Fog
GLfloat fogColor[] = { FOG_COLOR, 1.0 };
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, fog_start);
glFogf(GL_FOG_END, fog_end);
glFogf(GL_FOG_DENSITY, fog_thickness);
glFogfv(GL_FOG_COLOR, fogColor);
} else {
// No Fog
glDisable(GL_FOG);
}
}
ENTRYPOINT void draw_bang (ModeInfo *mi)
{
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GLfloat camx, camz;
float r = 10.0;
int LightPos[4] = {-10,0,0,1};
int MatSpec [4] = {1,1,1,1};
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bang->glx_context));
glMaterialiv(GL_FRONT_AND_BACK,GL_SPECULAR,MatSpec);
glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,100);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* set camera position */
camx = r*sin(bang->alpha) + 0.5;
camz = r*cos(bang->alpha) + 0.5;
bang->alpha += 0.01;
if (bang->alpha == 360)
{
bang->alpha = 0;
}
gluLookAt(camx, 0.0, camz, 0.0, 0.0, 0.0, 0, 1, 0);
glLightiv(GL_LIGHT0, GL_POSITION, LightPos);
/* gluLookAt(10, 0.0, 10, 0, 0, 0, 0, 1, 0);*/
glPushMatrix ();
drawsphere(0.1, 0.0, 0.0, 0.0);
drawsphere(0.5, 3.0, 0.0, 0.0);
drawsphere(1.0, 6.0, 0.0, 0.0);
glPopMatrix ();
if (MI_IS_FPS(mi)) do_fps (mi);
glXSwapBuffers(dpy, window);
}
void init(void){
GLfloat luz_ambiente[] = {0.45, 0.45, 0.45, 1.0};
GLfloat luz0_especular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat luz0_difusa[] = {0.35, 0.35, 0.35, 1.0};
GLfloat luz0_posicion[] = {200.0, 200.0, 200.0, 1.0};
GLfloat luz0_direccion[] = {0.0, 0.0, 0.0};
GLUquadricObj *Qflat;
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(winWidth, winHeight);
glutInitWindowPosition(100, 100);
glutCreateWindow("Objeto 3D compuesto");
glColor3f(1.0, 1.0, 1.0);
Qflat = gluNewQuadric();
gluQuadricDrawStyle(Qflat, GLU_FILL);
gluQuadricNormals(Qflat, GLU_SMOOTH);
gluQuadricOrientation(Qflat, GLU_INSIDE);
gluQuadricTexture(Qflat, GL_TRUE);
ratio=(GLfloat)winWidth/(GLfloat)winHeight;
Vx=0.0; Vz=235.0; Vy=30.0; Vtheta=3*PI/2.0;
//luz y sombreado
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,luz_ambiente);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMateriali(GL_FRONT, GL_SHININESS, 60);
glLightfv(GL_LIGHT0,GL_DIFFUSE,luz0_difusa);
glLightfv(GL_LIGHT0,GL_SPECULAR,luz0_especular);
glLightfv(GL_LIGHT0,GL_POSITION,luz0_posicion);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,luz0_direccion);
glEnable(GL_LIGHT0);
//lista room
Lroom=glGenLists(1); glNewList(Lroom,GL_COMPILE); room(LADO); glEndList();
//lista casa
Lcasa=glGenLists(1); glNewList(Lcasa,GL_COMPILE); casa(200); glEndList();
}
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();
}
/*
=============
drawFace
=============
Draws a textured face. Take note that the texture vertex must come BEFORE the
vertex that it will be assigned too.
Texture Coordinate Orrientation
(0,1)-------------(1,1)
| |
| Image |
| |
| |
(0,0)-------------(1,0)
*/
void init (void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_COLOR_MATERIAL);
GLfloat lightPos[] = { 5.0f, 5.0f, 0.0f, 1.0f };
GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f};
GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat ambientLight[] = { 0.5f, 0.5f, 0.5f, 1.0f};
GLfloat spotDir[] = { 0.0f, 0.0f, -1.0f };
// Set up and enable light 0
// Supply a slight ambient light so the objects can be seen
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);
// The light is composed of just diffuse and specular components
glLightfv(GL_LIGHT0,GL_DIFFUSE,ambientLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
// Specific spot effects
// Cut off angle is 60 degrees
glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,60.0f);
// Fairly shiny spot
glLightf(GL_LIGHT0,GL_SPOT_EXPONENT,100.0f);
// Enable color tracking
glEnable(GL_COLOR_MATERIAL);
// Set Material properties to follow glColor values
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
// All materials hereafter have full specular reflectivity
// with a high shine
glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
glMateriali(GL_FRONT, GL_SHININESS,128);
}
BOOL Initialize (GL_Window* window, Keys* keys) // Any GL Init Code & User Initialiazation Goes Here
{
g_window = window;
g_keys = keys;
// Start Of User Initialization
angle = 0.0f; // Set Starting Angle To Zero
BlurTexture = EmptyTexture(); // Create Our Empty Texture
glViewport(0 , 0,window->init.width ,window->init.height); // Set Up A Viewport
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
gluPerspective(50, (float)window->init.width/(float)window->init.height, 5, 2000); // Set Our Perspective
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
glEnable(GL_DEPTH_TEST); // Enable Depth Testing
GLfloat global_ambient[4]={0.2f, 0.2f, 0.2f, 1.0f}; // Set Ambient Lighting To Fairly Dark Light (No Color)
GLfloat light0pos[4]= {0.0f, 5.0f, 10.0f, 1.0f}; // Set The Light Position
GLfloat light0ambient[4]= {0.2f, 0.2f, 0.2f, 1.0f}; // More Ambient Light
GLfloat light0diffuse[4]= {0.3f, 0.3f, 0.3f, 1.0f}; // Set The Diffuse Light A Bit Brighter
GLfloat light0specular[4]={0.8f, 0.8f, 0.8f, 1.0f}; // Fairly Bright Specular Lighting
GLfloat lmodel_ambient[]= {0.2f,0.2f,0.2f,1.0f}; // And More Ambient Light
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient); // Set The Ambient Light Model
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient); // Set The Global Ambient Light Model
glLightfv(GL_LIGHT0, GL_POSITION, light0pos); // Set The Lights Position
glLightfv(GL_LIGHT0, GL_AMBIENT, light0ambient); // Set The Ambient Light
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0diffuse); // Set The Diffuse Light
glLightfv(GL_LIGHT0, GL_SPECULAR, light0specular); // Set Up Specular Lighting
glEnable(GL_LIGHTING); // Enable Lighting
glEnable(GL_LIGHT0); // Enable Light0
glShadeModel(GL_SMOOTH); // Select Smooth Shading
glMateriali(GL_FRONT, GL_SHININESS, 128);
glClearColor(0.0f, 0.0f, 0.0f, 0.5); // Set The Clear Color To Black
return TRUE; // Return TRUE (Initialization Successful)
}
/* draw a highly tesselated sphere with a specular highlight */
void
makeHighlight(int shinyness)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glPushMatrix(); /* starts as modelview */
glLoadIdentity();
glTranslatef(0.f, 0.f, -texdim/2.f);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-texdim/2., texdim/2., -texdim/2., texdim/2., 0., texdim/2.);
glPushAttrib(GL_LIGHTING_BIT|GL_VIEWPORT_BIT);
glViewport(0, 0, texdim, texdim);
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_DIFFUSE, zero);
glLightfv(GL_LIGHT0, GL_POSITION, lightpos); /* light direction */
/* XXX TODO, range check an report errors */
glMateriali(GL_FRONT, GL_SHININESS, shinyness); /* cosine power */
glMaterialfv(GL_FRONT, GL_AMBIENT, zero);
glMaterialfv(GL_FRONT, GL_DIFFUSE, zero);
glMaterialfv(GL_FRONT, GL_SPECULAR, color);
glDisable(GL_TEXTURE_2D);
glCallList(1);
glEnable(GL_TEXTURE_2D);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glReadPixels(0, 0, texdim, texdim, GL_RGB, GL_FLOAT, lighttex);
glBindTexture(GL_TEXTURE_2D, HIGHLIGHT_TEX);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texdim, texdim, 0, GL_RGB,
GL_FLOAT, lighttex);
}
//设置光照
void SetupLights()
{
GLfloat ambientLight[] = { 0.45f, 0.45f, 0.5f, 1.0f };//环境光
GLfloat diffuseLight[] = { 0.55f, 0.55f, 0.55f, 1.0f };//漫反射
GLfloat specularLight[] = { 0.6f, 0.6f, 0.6f, 1.0f };//镜面光
GLfloat lightPos[] = { 50.0f, 80.0f, 60.0f, 1.0f };//光源位置
glEnable(GL_LIGHTING); //启用光照
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight); //设置环境光源
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight); //设置漫反射光源
glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight); //设置镜面光源
glLightfv(GL_LIGHT0, GL_POSITION, lightPos); //设置灯光位置
glEnable(GL_LIGHT0); //打开第一个灯光
glEnable(GL_COLOR_MATERIAL); //启用材质的颜色跟踪
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); //指定材料着色的面
glMaterialfv(GL_FRONT, GL_SPECULAR, specularLight); //指定材料对镜面光的反应
glMateriali(GL_FRONT, GL_SHININESS, 100); //指定反射系数
}
void tree()
{
treelist=glGenLists(1);
glNewList(treelist,GL_COMPILE);
float mat_ambient[] = { 0.5, 0.2, 0.0, 1.0 };
float mat_diffuse[] = { 0, 0.8, 0.8, 1.0 };
float mat_specular[] = { 0, 0, 0, 1.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_SPECULAR, mat_specular);
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 50);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qobj = gluNewQuadric();
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_2D);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
glBindTexture(GL_TEXTURE_2D, texture[12]);
glPushMatrix();
glTranslatef(0, 0, 0);
glRotatef(-90, 1, 0, 0);
gluCylinder(qobj,3,1,20,20,10);
glBindTexture(GL_TEXTURE_2D, texture[11]);
glRotatef(90, 1, 0, 0);
glTranslatef(0, 20, 0);
gluSphere(qobj, 7, 6, 6);
glPopMatrix();
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_2D);
glEndList();
}
// This function does any needed initialization on the rendering
// context.
void SetupRC()
{
glEnable(GL_DEPTH_TEST); // Hidden surface removal
glFrontFace(GL_CCW); // Counter clock-wise polygons face out
glEnable(GL_CULL_FACE); // Do not calculate inside of jet
{
// Enable lighting
glEnable(GL_LIGHTING);
// Light values and coordinates
// GLfloat ambientLight[] = { 0.3f, 0.3f, 0.3f, 1.0f };
// GLfloat diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f };
GLfloat specular[] = { 1.0f, 0.0f, 0.0f, 1.0f };
// Setup and enable light 0
// glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
// glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glLightfv(GL_LIGHT0,GL_SPECULAR, specular);
glEnable(GL_LIGHT0);
}
{
// Enable color tracking
glEnable(GL_COLOR_MATERIAL);
// Set Material properties to follow glColor values
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
GLfloat specref[] = { 1.0f, 0.0f, 0.0f, 1.0f };
// All materials hereafter have full specular reflectivity
// with a high shine
glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
glMateriali(GL_FRONT, GL_SHININESS, 128);
}
glEnable(GL_NORMALIZE);
// Light blue background
// glClearColor(0.0f, 0.0f, 1.0f, 1.0f );
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
}
extern "C" void Draw (void) // Draw The Scene
{
static double ticks;
static double lastticks;
glEnable(GL_DEPTH_TEST); // Enable Depth Testing
GLfloat global_ambient[4]={0.2f, 0.2f, 0.2f, 1.0f}; // Set Ambient Lighting To Fairly Dark Light (No Color)
GLfloat light0pos[4]= {0.0f, 5.0f, 10.0f, 1.0f}; // Set The Light Position
GLfloat light0ambient[4]= {0.2f, 0.2f, 0.2f, 1.0f}; // More Ambient Light
GLfloat light0diffuse[4]= {0.3f, 0.3f, 0.3f, 1.0f}; // Set The Diffuse Light A Bit Brighter
GLfloat light0specular[4]={0.8f, 0.8f, 0.8f, 1.0f}; // Fairly Bright Specular Lighting
GLfloat lmodel_ambient[]= {0.2f,0.2f,0.2f,1.0f}; // And More Ambient Light
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient); // Set The Ambient Light Model
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient); // Set The Global Ambient Light Model
glLightfv(GL_LIGHT0, GL_POSITION, light0pos); // Set The Lights Position
glLightfv(GL_LIGHT0, GL_AMBIENT, light0ambient); // Set The Ambient Light
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0diffuse); // Set The Diffuse Light
glLightfv(GL_LIGHT0, GL_SPECULAR, light0specular); // Set Up Specular Lighting
glEnable(GL_LIGHTING); // Enable Lighting
glEnable(GL_LIGHT0); // Enable Light0
glShadeModel(GL_SMOOTH); // Select Smooth Shading
glMateriali(GL_FRONT, GL_SHININESS, 128);
glClearColor(0.0f, 0.0f, 0.0f, 0.5); // Set The Clear Color To Black
ticks=SDL_GetTicks();
if(Update (ticks - lastticks))
return;
lastticks = ticks;
glClearColor(0.0f, 0.0f, 0.0f, 0.5); // Set The Clear Color To Black
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity(); // Reset The View
RenderToTexture(); // Render To A Texture
ProcessHelix(); // Draw Our Helix
DrawBlur(25,0.02f); // Draw The Blur Effect
}
void guangzhao()
{
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
float huanjin[]={0.3,0.3,0.3,1};
float sanshe[]={0.7,0.7,0.7,1};
float weizhi[]={1,1,1,0};
float jinmian[]={1,1,1,1};
float fanshelv[]={1,1,1,1};
glLightfv(GL_LIGHT0,GL_POSITION,weizhi);
glLightfv(GL_LIGHT0,GL_AMBIENT,huanjin);
glLightfv(GL_LIGHT0,GL_DIFFUSE,sanshe);
glLightfv(GL_LIGHT0,GL_SPECULAR,jinmian);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT,GL_SPECULAR,fanshelv);
glMateriali(GL_FRONT,GL_SHININESS,120);
}
void PCViewerWidget::initializeGL()
{
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glClearDepth(1.0);
glDepthFunc(GL_LESS);
glShadeModel(GL_SMOOTH);
// line anti-aliasing
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LINE_SMOOTH);
// light values and coordinates
glFrontFace(GL_CCW);
glEnable(GL_CULL_FACE);
// Enable lighting
// glEnable(GL_LIGHTING);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, whiteLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, sourceLight);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glEnable(GL_LIGHT0);
// Enable color tracking
glEnable(GL_COLOR_MATERIAL);
// Set Material properties to follow glColor values
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
// Set Material shine with specular light
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMateriali(GL_FRONT, GL_SHININESS, 1);
resizeGL(1280, 480);
}
