int main(int argc, char *argv[]) { unsigned *cloud; int texcomps, texwid, texht; GLUquadricObj *sphere; /* start and end of particles */ static GLfloat begin[] = {0.f, -25.f, 0.f}; static GLfloat end[] = {0.f,-100.f, 0.f}; static GLfloat fogcolor[] = {.4f, .4f, .4f, 1.f}; glutInitWindowSize(winwid, winht); glutInit(&argc, argv); if(argc > 1) { char *args = argv[1]; int done = GL_FALSE; while(!done) { switch(*args) { case 's': /* single buffer */ printf("Single Buffered\n"); dblbuf = GL_FALSE; break; case '-': /* do nothing */ break; case 0: done = GL_TRUE; break; } args++; } } if(dblbuf) glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE); else glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL); (void)glutCreateWindow("snow demo"); glutDisplayFunc(redraw); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); glutIdleFunc(idle); glutCreateMenu(menu); glutAddMenuEntry("Toggle Overcast (o, O)", OVERCAST); glutAddMenuEntry("Toggle Fog (f, F)", FOG); glutAddMenuEntry("Toggle Snow (s, S)", SNOW); glutAddMenuEntry("Bigger Flakes (+)", BIGGER); glutAddMenuEntry("Smaller Flakes (-)", SMALLER); glutAddMenuEntry("Reset Flake Size to One (r, R)", RESETSIZE); glutAddMenuEntry("Toggle Point Antialiasing (a, A)", ANTIALIAS); glutAddMenuEntry("Snow Blending (b, B)", BLEND); glutAddMenuEntry("Exit Program", EXIT); glutAttachMenu(GLUT_RIGHT_BUTTON); printf("OpenGL Version %s\n", glGetString(GL_VERSION)); /* draw a perspective scene */ glMatrixMode(GL_PROJECTION); glFrustum(-5., 5., -5., 5., 10., 1000.); glMatrixMode(GL_MODELVIEW); updateMV(); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); /* turn on features */ glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); /* place light 0 in the right place */ glLightfv(GL_LIGHT0, GL_POSITION, lightpos); glClearColor(0.f, 0.f, 1.f, 1.f); glFogfv(GL_FOG_COLOR, fogcolor); glFogi(GL_FOG_MODE, GL_LINEAR); glFogf(GL_FOG_START, -200.f); glFogf(GL_FOG_END, 200.f); glHint(GL_FOG_HINT, GL_NICEST); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); /* makes texturing faster, and looks better than GL_LINEAR */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glNewList(LIGHT, GL_COMPILE); glDisable(GL_LIGHTING); sphere = gluNewQuadric(); glColor3f(.7f, .2f, .7f); gluSphere(sphere, 5.f, 10, 10); gluDeleteQuadric(sphere); glEnable(GL_LIGHTING); glEndList(); /* 10 X 20; vary size with transforms */ /* one corner of house on origin; bottom on xz plane */ glNewList(HOUSE, GL_COMPILE); glBegin(GL_QUADS); /* walls of house */ glColor3f(1.f, 1.f, 0.f); /* front */ glNormal3f( 0.f, 0.f, 1.f); glVertex3i( 0, 0, 0); glVertex3i(10, 0, 0); glVertex3i(10,10, 0); glVertex3i( 0,10, 0); /* back */ glNormal3f( 0.f, 0.f, -1.f); glVertex3i( 0, 0, -20); glVertex3i( 0,10, -20); glVertex3i(10,10, -20); glVertex3i(10, 0, -20); /* left */ glNormal3f(-1, 0.f, 0.f); glVertex3i( 0, 0, 0); glVertex3i( 0, 10, 0); glVertex3i( 0, 10, -20); glVertex3i( 0, 0, -20); /* right */ glNormal3f( 1.f, 0.f, 0.f); glVertex3i(10, 0, 0); glVertex3i(10, 0, -20); glVertex3i(10, 10, -20); glVertex3i(10, 10, 0); /* roof of house */ glColor3f(.8f, .1f, .1f); /* left top */ glNormal3f(-.707f, .707f, 0.f); glVertex3i( 0, 10, 0); glVertex3i( 5, 15, 0); glVertex3i( 5, 15, -20); glVertex3i( 0, 10, -20); /* right top */ glNormal3f( .707f, .707f, 0.f); glVertex3i(10, 10, 0); glVertex3i(10, 10, -20); glVertex3i( 5, 15, -20); glVertex3i( 5, 15, 0); glEnd(); glBegin(GL_TRIANGLES); /* front */ glNormal3f( 0.f, 0.f, 1.f); glVertex3i( 0, 10, 0); glVertex3i(10, 10, 0); glVertex3i( 5, 15, 0); /* back */ glNormal3f( 0.f, 0.f, -1.f); glVertex3i( 0, 10, -20); glVertex3i( 5, 15, -20); glVertex3i(10, 10, -20); glEnd(); glEndList(); glEnable(GL_CULL_FACE); /* load pattern for current 2d texture */ cloud = read_texture("../../data/clouds.bw", &texwid, &texht, &texcomps); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, texwid, texht, GL_RGBA, GL_UNSIGNED_BYTE, cloud); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); free(cloud); initpart(&psys, begin, end, 200, 6000); updateptr = updatepart0; CHECK_ERROR("main()"); glutMainLoop(); return 0; }
/* Initialize broad parameters for OpenGL */ void EDA_3D_CANVAS::InitGL() { wxSize size = GetClientSize(); if( !m_init ) { m_init = true; g_Parm_3D_Visu.m_Zoom = 1.0; m_ZBottom = 1.0; m_ZTop = 10.0; glDisable( GL_CULL_FACE ); // show back faces glEnable( GL_DEPTH_TEST ); // Enable z-buferring glEnable( GL_LINE_SMOOTH ); glEnable( GL_COLOR_MATERIAL ); glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE ); /* speedups */ glEnable( GL_DITHER ); glShadeModel( GL_SMOOTH ); glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE ); glHint( GL_LINE_SMOOTH_HINT, GL_NICEST ); glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST ); // can be GL_FASTEST /* blend */ glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); } // set viewing projection glMatrixMode( GL_PROJECTION ); glLoadIdentity(); #define MAX_VIEW_ANGLE 160.0 / 45.0 if( g_Parm_3D_Visu.m_Zoom > MAX_VIEW_ANGLE ) g_Parm_3D_Visu.m_Zoom = MAX_VIEW_ANGLE; if( Parent()->ModeIsOrtho() ) { // OrthoReductionFactor is chosen so as to provide roughly the same size as // Perspective View const double orthoReductionFactor = 400 / g_Parm_3D_Visu.m_Zoom; // Initialize Projection Matrix for Ortographic View glOrtho( -size.x / orthoReductionFactor, size.x / orthoReductionFactor, -size.y / orthoReductionFactor, size.y / orthoReductionFactor, 1, 10 ); } else { // Ratio width / height of the window display double ratio_HV = (double) size.x / size.y; // Initialize Projection Matrix for Perspective View gluPerspective( 45.0 * g_Parm_3D_Visu.m_Zoom, ratio_HV, 1, 10 ); } // position viewer glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef( 0.0F, 0.0F, -( m_ZBottom + m_ZTop) / 2 ); // clear color and depth buffers glClearColor( g_Parm_3D_Visu.m_BgColor.m_Red, g_Parm_3D_Visu.m_BgColor.m_Green, g_Parm_3D_Visu.m_BgColor.m_Blue, 1 ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Setup light sources: SetLights(); CheckGLError(); }
void ccGenericMesh::drawMeOnly(CC_DRAW_CONTEXT& context) { ccGenericPointCloud* vertices = getAssociatedCloud(); if (!vertices) return; handleColorRamp(context); //3D pass if (MACRO_Draw3D(context)) { //any triangle? unsigned triNum = size(); if (triNum == 0) return; //L.O.D. bool lodEnabled = (triNum > GET_MAX_LOD_FACES_NUMBER() && context.decimateMeshOnMove && MACRO_LODActivated(context)); unsigned decimStep = (lodEnabled ? (unsigned)ceil((float)triNum*3 / (float)GET_MAX_LOD_FACES_NUMBER()) : 1); unsigned displayedTriNum = triNum / decimStep; //display parameters glDrawParams glParams; getDrawingParameters(glParams); glParams.showNorms &= bool(MACRO_LightIsEnabled(context)); //vertices visibility const ccGenericPointCloud::VisibilityTableType* verticesVisibility = vertices->getTheVisibilityArray(); bool visFiltering = (verticesVisibility && verticesVisibility->isAllocated()); //wireframe ? (not compatible with LOD) bool showWired = isShownAsWire() && !lodEnabled; //per-triangle normals? bool showTriNormals = (hasTriNormals() && triNormsShown()); //fix 'showNorms' glParams.showNorms = showTriNormals || (vertices->hasNormals() && m_normalsDisplayed); //materials & textures bool applyMaterials = (hasMaterials() && materialsShown()); bool showTextures = (hasTextures() && materialsShown() && !lodEnabled); //GL name pushing bool pushName = MACRO_DrawEntityNames(context); //special case: triangle names pushing (for picking) bool pushTriangleNames = MACRO_DrawTriangleNames(context); pushName |= pushTriangleNames; if (pushName) { //not fast at all! if (MACRO_DrawFastNamesOnly(context)) return; glPushName(getUniqueIDForDisplay()); //minimal display for picking mode! glParams.showNorms = false; glParams.showColors = false; //glParams.showSF --> we keep it only if SF 'NaN' values are hidden showTriNormals = false; applyMaterials = false; showTextures = false; } //in the case we need to display scalar field colors ccScalarField* currentDisplayedScalarField = 0; bool greyForNanScalarValues = true; unsigned colorRampSteps = 0; ccColorScale::Shared colorScale(0); if (glParams.showSF) { assert(vertices->isA(CC_POINT_CLOUD)); ccPointCloud* cloud = static_cast<ccPointCloud*>(vertices); greyForNanScalarValues = (cloud->getCurrentDisplayedScalarField() && cloud->getCurrentDisplayedScalarField()->areNaNValuesShownInGrey()); if (greyForNanScalarValues && pushName) { //in picking mode, no need to take SF into account if we don't hide any points! glParams.showSF = false; } else { currentDisplayedScalarField = cloud->getCurrentDisplayedScalarField(); colorScale = currentDisplayedScalarField->getColorScale(); colorRampSteps = currentDisplayedScalarField->getColorRampSteps(); assert(colorScale); //get default color ramp if cloud has no scale associated?! if (!colorScale) colorScale = ccColorScalesManager::GetUniqueInstance()->getDefaultScale(ccColorScalesManager::BGYR); } } //materials or color? bool colorMaterial = false; if (glParams.showSF || glParams.showColors) { applyMaterials = false; colorMaterial = true; glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); } //in the case we need to display vertex colors ColorsTableType* rgbColorsTable = 0; if (glParams.showColors) { if (isColorOverriden()) { glColor3ubv(m_tempColor); glParams.showColors = false; } else { assert(vertices->isA(CC_POINT_CLOUD)); rgbColorsTable = static_cast<ccPointCloud*>(vertices)->rgbColors(); } } else { glColor3fv(context.defaultMat.diffuseFront); } if (glParams.showNorms) { //DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version can fall to 1.0! glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glEnable(GL_LIGHTING); context.defaultMat.applyGL(true,colorMaterial); } //in the case we need normals (i.e. lighting) NormsIndexesTableType* normalsIndexesTable = 0; ccNormalVectors* compressedNormals = 0; if (glParams.showNorms) { assert(vertices->isA(CC_POINT_CLOUD)); normalsIndexesTable = static_cast<ccPointCloud*>(vertices)->normals(); compressedNormals = ccNormalVectors::GetUniqueInstance(); } //stipple mask if (stipplingEnabled()) EnableGLStippleMask(true); if (!pushTriangleNames && !visFiltering && !(applyMaterials || showTextures) && (!glParams.showSF || greyForNanScalarValues)) { //the GL type depends on the PointCoordinateType 'size' (float or double) GLenum GL_COORD_TYPE = sizeof(PointCoordinateType) == 4 ? GL_FLOAT : GL_DOUBLE; glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3,GL_COORD_TYPE,0,GetVertexBuffer()); if (glParams.showNorms) { glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_COORD_TYPE,0,GetNormalsBuffer()); } if (glParams.showSF || glParams.showColors) { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(3,GL_UNSIGNED_BYTE,0,GetColorsBuffer()); } //we can scan and process each chunk separately in an optimized way //we mimic the way ccMesh beahves by using virtual chunks! unsigned chunks = static_cast<unsigned>(ceil((double)displayedTriNum/(double)MAX_NUMBER_OF_ELEMENTS_PER_CHUNK)); unsigned chunkStart = 0; const colorType* col = 0; for (unsigned k=0; k<chunks; ++k, chunkStart += MAX_NUMBER_OF_ELEMENTS_PER_CHUNK) { //virtual chunk size const unsigned chunkSize = k+1 < chunks ? MAX_NUMBER_OF_ELEMENTS_PER_CHUNK : (displayedTriNum % MAX_NUMBER_OF_ELEMENTS_PER_CHUNK); //vertices PointCoordinateType* _vertices = GetVertexBuffer(); for (unsigned n=0; n<chunkSize; n+=decimStep) { const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n); memcpy(_vertices,vertices->getPoint(ti->i1)->u,sizeof(PointCoordinateType)*3); _vertices+=3; memcpy(_vertices,vertices->getPoint(ti->i2)->u,sizeof(PointCoordinateType)*3); _vertices+=3; memcpy(_vertices,vertices->getPoint(ti->i3)->u,sizeof(PointCoordinateType)*3); _vertices+=3; } //scalar field if (glParams.showSF) { colorType* _rgbColors = GetColorsBuffer(); assert(colorScale); for (unsigned n=0; n<chunkSize; n+=decimStep) { const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n); col = currentDisplayedScalarField->getValueColor(ti->i1); memcpy(_rgbColors,col,sizeof(colorType)*3); _rgbColors += 3; col = currentDisplayedScalarField->getValueColor(ti->i2); memcpy(_rgbColors,col,sizeof(colorType)*3); _rgbColors += 3; col = currentDisplayedScalarField->getValueColor(ti->i3); memcpy(_rgbColors,col,sizeof(colorType)*3); _rgbColors += 3; } } //colors else if (glParams.showColors) { colorType* _rgbColors = GetColorsBuffer(); for (unsigned n=0; n<chunkSize; n+=decimStep) { const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n); memcpy(_rgbColors,rgbColorsTable->getValue(ti->i1),sizeof(colorType)*3); _rgbColors += 3; memcpy(_rgbColors,rgbColorsTable->getValue(ti->i2),sizeof(colorType)*3); _rgbColors += 3; memcpy(_rgbColors,rgbColorsTable->getValue(ti->i3),sizeof(colorType)*3); _rgbColors += 3; } } //normals if (glParams.showNorms) { PointCoordinateType* _normals = GetNormalsBuffer(); if (showTriNormals) { for (unsigned n=0; n<chunkSize; n+=decimStep) { CCVector3 Na, Nb, Nc; getTriangleNormals(chunkStart + n, Na, Nb, Nc); memcpy(_normals,Na.u,sizeof(PointCoordinateType)*3); _normals+=3; memcpy(_normals,Nb.u,sizeof(PointCoordinateType)*3); _normals+=3; memcpy(_normals,Nc.u,sizeof(PointCoordinateType)*3); _normals+=3; } } else { for (unsigned n=0; n<chunkSize; n+=decimStep) { const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n); memcpy(_normals,vertices->getPointNormal(ti->i1),sizeof(PointCoordinateType)*3); _normals+=3; memcpy(_normals,vertices->getPointNormal(ti->i2),sizeof(PointCoordinateType)*3); _normals+=3; memcpy(_normals,vertices->getPointNormal(ti->i3),sizeof(PointCoordinateType)*3); _normals+=3; } } } if (!showWired) { glDrawArrays(lodEnabled ? GL_POINTS : GL_TRIANGLES,0,(chunkSize/decimStep)*3); } else { glDrawElements(GL_LINES,(chunkSize/decimStep)*6,GL_UNSIGNED_INT,GetWireVertexIndexes()); } } //disable arrays glDisableClientState(GL_VERTEX_ARRAY); if (glParams.showNorms) glDisableClientState(GL_NORMAL_ARRAY); if (glParams.showSF || glParams.showColors) glDisableClientState(GL_COLOR_ARRAY); } else { //current vertex color const colorType *col1=0,*col2=0,*col3=0; //current vertex normal const PointCoordinateType *N1=0,*N2=0,*N3=0; //current vertex texture coordinates float *Tx1=0,*Tx2=0,*Tx3=0; //loop on all triangles int lasMtlIndex = -1; if (showTextures) { //#define TEST_TEXTURED_BUNDLER_IMPORT #ifdef TEST_TEXTURED_BUNDLER_IMPORT glPushAttrib(GL_COLOR_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(context.sourceBlend, context.destBlend); #endif glEnable(GL_TEXTURE_2D); } if (pushTriangleNames) glPushName(0); GLenum triangleDisplayType = lodEnabled ? GL_POINTS : showWired ? GL_LINE_LOOP : GL_TRIANGLES; glBegin(triangleDisplayType); //per-triangle normals const NormsIndexesTableType* triNormals = getTriNormsTable(); //materials const ccMaterialSet* materials = getMaterialSet(); for (unsigned n=0; n<triNum; ++n) { //current triangle vertices const CCLib::TriangleSummitsIndexes* tsi = getTriangleIndexes(n); //LOD: shall we display this triangle? if (n % decimStep) continue; if (visFiltering) { //we skip the triangle if at least one vertex is hidden if ((verticesVisibility->getValue(tsi->i1) != POINT_VISIBLE) || (verticesVisibility->getValue(tsi->i2) != POINT_VISIBLE) || (verticesVisibility->getValue(tsi->i3) != POINT_VISIBLE)) continue; } if (glParams.showSF) { assert(colorScale); col1 = currentDisplayedScalarField->getValueColor(tsi->i1); if (!col1) continue; col2 = currentDisplayedScalarField->getValueColor(tsi->i2); if (!col2) continue; col3 = currentDisplayedScalarField->getValueColor(tsi->i3); if (!col3) continue; } else if (glParams.showColors) { col1 = rgbColorsTable->getValue(tsi->i1); col2 = rgbColorsTable->getValue(tsi->i2); col3 = rgbColorsTable->getValue(tsi->i3); } if (glParams.showNorms) { if (showTriNormals) { assert(triNormals); int n1,n2,n3; getTriangleNormalIndexes(n,n1,n2,n3); N1 = (n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n1)) : 0); N2 = (n1==n2 ? N1 : n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n2)) : 0); N3 = (n1==n3 ? N1 : n3>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n3)) : 0); } else { N1 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i1)); N2 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i2)); N3 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i3)); } } if (applyMaterials || showTextures) { assert(materials); int newMatlIndex = this->getTriangleMtlIndex(n); //do we need to change material? if (lasMtlIndex != newMatlIndex) { assert(newMatlIndex<(int)materials->size()); glEnd(); if (showTextures) { GLuint texID = (newMatlIndex>=0 ? (*materials)[newMatlIndex].texID : 0); if (texID>0) assert(glIsTexture(texID)); glBindTexture(GL_TEXTURE_2D, texID); } //if we don't have any current material, we apply default one (newMatlIndex>=0 ? (*materials)[newMatlIndex] : context.defaultMat).applyGL(glParams.showNorms,false); glBegin(triangleDisplayType); lasMtlIndex=newMatlIndex; } if (showTextures) { getTriangleTexCoordinates(n,Tx1,Tx2,Tx3); } } if (pushTriangleNames) { glEnd(); glLoadName(n); glBegin(triangleDisplayType); } else if (showWired) { glEnd(); glBegin(triangleDisplayType); } //vertex 1 if (N1) ccGL::Normal3v(N1); if (col1) glColor3ubv(col1); if (Tx1) glTexCoord2fv(Tx1); ccGL::Vertex3v(vertices->getPoint(tsi->i1)->u); //vertex 2 if (N2) ccGL::Normal3v(N2); if (col2) glColor3ubv(col2); if (Tx2) glTexCoord2fv(Tx2); ccGL::Vertex3v(vertices->getPoint(tsi->i2)->u); //vertex 3 if (N3) ccGL::Normal3v(N3); if (col3) glColor3ubv(col3); if (Tx3) glTexCoord2fv(Tx3); ccGL::Vertex3v(vertices->getPoint(tsi->i3)->u); } glEnd(); if (pushTriangleNames) glPopName(); if (showTextures) { #ifdef TEST_TEXTURED_BUNDLER_IMPORT glPopAttrib(); //GL_COLOR_BUFFER_BIT #endif glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); } } if (stipplingEnabled()) EnableGLStippleMask(false); if (colorMaterial) glDisable(GL_COLOR_MATERIAL); if (glParams.showNorms) { glDisable(GL_LIGHTING); glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); } if (pushName) glPopName(); } }
/** initialization handler */ ENTRYPOINT void init_chess(ModeInfo *mi) { Chesscreen *cs; int screen = MI_SCREEN(mi); if(!qs && !(qs = (Chesscreen *) calloc(MI_NUM_SCREENS(mi), sizeof(Chesscreen)))) return; cs = &qs[screen]; cs->window = MI_WINDOW(mi); cs->wire = MI_IS_WIREFRAME(mi); cs->trackball = gltrackball_init (); cs->oldwhite = -1; cs->colors[0][0] = 1.0; cs->colors[0][1] = 0.5; cs->colors[0][2] = 0.0; cs->colors[1][0] = 0.6; cs->colors[1][1] = 0.6; cs->colors[1][2] = 0.6; cs->done = 1; cs->count = 99; cs->mod = 1.4; /* cs->position[0] = 0.0; */ /* cs->position[1] = 5.0; */ /* cs->position[2] = 5.0; */ /* cs->position[3] = 1.0; */ cs->position[0] = 0.0; cs->position[1] = 24.0; cs->position[2] = 2.0; cs->position[3] = 1.0; cs->position2[0] = 5.0; cs->position2[1] = 5.0; cs->position2[2] = 5.0; cs->position2[3] = 1.0; cs->ground[0] = 0.0; cs->ground[1] = 1.0; cs->ground[2] = 0.0; cs->ground[3] = -0.00001; cs->oldgame = -1; if((cs->glx_context = init_GL(mi))) reshape_chess(mi, MI_WIDTH(mi), MI_HEIGHT(mi)); else MI_CLEARWINDOW(mi); if (!cs->wire) { glDepthFunc(GL_LEQUAL); glClearStencil(0); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); make_piece_texture(cs); make_board_texture(cs); } gen_model_lists( classic, cs->poly_counts); if(!cs->wire) { setup_lights(cs); glColorMaterial(GL_FRONT, GL_DIFFUSE); glShadeModel(smooth ? GL_SMOOTH : GL_FLAT); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_DEPTH_TEST); } else glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); }
/* Initialises texturing, lighting, display lists, and everything else associated with the model. */ void init_opengl_cinetheodolite(struct_opengl_cinetheodolite * s) { s->SIZE_ARTICULATION = 0.5;// for drawing articulations //----------------------------------- // denavit hartenberg parameters //----------------------------------- s->type1 = ROTOIDE; s->th1 = 0; s->d1 = 0.5; s->a1 = 0; s->alpha1 = -90; s->type2 = ROTOIDE; s->th2 = 0; s->d2 = 0; s->a2 = 1; s->alpha2 = 0; /*-------------------------------------------- * pour trace du sol [ largeur et epaisseur ] * -------------------------------------------*/ s->draw_sol = FALSE; s->width_sol = 10; s->depth_sol = 0.1; s->SCALE = 10; /*---------------------------------------------------- * angles de rotation et point de vue initial * (ne pas modifier sans ) * --------------------------------------------------- */ s->view_point_z = -5; // distance of view point = 5m , on z axis of camera s->view_y = 180; s->view_x = 245; s->view_point_x = 0; // distance of view point = 10m , on z axis of camera s->view_point_y = 0; // distance of view point = 10m , on z axis of camera /*----------------------------------------------------- - switches d'affichage -----------------------------------------------------*/ s->shaded = TRUE; s->context = _NOANIMATION; s->texture = TRUE; s->transparent = TRUE; s->light1 = TRUE; s->light2 = TRUE; /*------------------------------------------------------- - NE PAS MODIFIER :initialisations lumieres, textures , images --------------------------------------------------------*/ GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0}; GLfloat mat_shininess[] = {50.0}; GLfloat light_position1[] = {10.0, 10.0, 10.0, 0.0}; GLfloat light_position2[] = {-1.0, 1.0, 1.0, 0.0}; GLfloat mat_emission[] = {0.2, 0.2, 0.2, 0.2}; glClearColor(0.0, 0.0, 0.0, 0.0); s->obj = gluNewQuadric(); make_image_opengl_cinetheodolite(s); /* Set up Texturing */ glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage2D(GL_TEXTURE_2D, 0, 3, IMAGE_WIDTH, IMAGE_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, s->image); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); /* Set up Lighting */ // glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); // glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission); // glLightfv(GL_LIGHT0, GL_POSITION, light_position1); // glLightfv(GL_LIGHT1, GL_POSITION, light_position2); /* Initial render mode is with full shading and LIGHT 0 enabled. */ glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); //glEnable(GL_LIGHT1); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glDisable(GL_ALPHA_TEST); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glShadeModel(GL_SMOOTH); // light gray for background color glClearColor(0.6, 0.6, 0.6, 0.0); /* Initialise display lists */ s->params = NULL; s->context = _NOANIMATION; }
int main(int argc, char **argv) { if(cnt<1){ std::cout<<"main"<<'\n'; //findAdjustway(MODEL); cnt+=1; } glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(1000, 500); glutCreateWindow("Xshading"); glutReshapeFunc(myReshape); glutDisplayFunc(display); glutIdleFunc(spinCube); glutMouseFunc(mouseButton); glutMotionFunc(mouseMotion); glutKeyboardFunc(myKeys); glutTimerFunc(33, update, 0); glEnable(GL_DEPTH_TEST); //Font = FontCreate(wglGetCurrentDC(), "Times", 32, 0, 1); //Read model MODEL = glmReadOBJ("bunny.obj");//Millennium_Falcon glmUnitize(MODEL); glmFacetNormals(MODEL); glmVertexNormals(MODEL, 60); // Light values and coordinates GLfloat ambientLight[] = { 0.1f, 0.1f, 0.1f, 1.0f }; GLfloat diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f }; GLfloat specular[] = { 5.0f, 0.7f, 0.7f, 1.0f }; GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f }; GLfloat shininess = 32.0f; // Enable lighting glEnable(GL_LIGHTING); // 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); // All materials hereafter have full specular reflectivity with a high shine glMaterialfv(GL_FRONT, GL_SPECULAR, specref); glMateriali(GL_FRONT, GL_SHININESS, shininess); // BackgroundColor glClearColor(0.7,0.7,0.7,0); // /* swLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight); swLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight); swLightfv(GL_LIGHT0,GL_SPECULAR, specular); swMaterialfv(GL_FRONT, GL_SPECULAR, specref); swMateriali(GL_FRONT, GL_SHININESS, shininess); */ glutMainLoop(); return 0; }
//on/off void ofxLightsOn(){ glEnable(GL_LIGHTING); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); }
void SetupGL() { //Parameter handling glShadeModel (GL_SMOOTH); // Accept fragment if it closer to the camera than the former one glDepthFunc(GL_LESS); // polygon rendering mode glEnable(GL_COLOR_MATERIAL); glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE ); //Set up light source //GLfloat light_position[] = { 0.0, 30.0,-50.0,0.0 }; GLfloat light_position[] = { 5.0, 5.0, 0.0, 1.0 }; glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // Background glClearColor( 0.1f, 0.1f, 0.1f, 1.0f ); // Register GLUT callbacks glutDisplayFunc(DisplayGL); glutKeyboardFunc(KeyboardGL); glutSpecialFunc(Specialkey); glutReshapeFunc(ReshapeGL); glutMouseFunc(MouseGL); glutMotionFunc(Mouse_active); //Call to the drawing function glutIdleFunc(Idle); last_time = glutGet(GLUT_ELAPSED_TIME); // Setup initial GL State glClearDepth( 1.0f ); // // Init GLEW if ( glewInit() != GLEW_OK ) { std::cerr << "Failed to initialize GLEW." << std::endl; exit(-1); } // Setup initial GL State glClearDepth( 1.0f ); std::cout << "Initialise OpenGL: Success!" << std::endl; //VAO //glGenVertexArrays(1, &VertexArrayID); //glBindVertexArray(VertexArrayID); // Create and compile our GLSL program from the shaders programID_1 = LoadShaders( "TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader" ); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); Projection = glm::perspective(initialFoV, (float)WINDOW_WIDTH / WINDOW_HEIGHT, 0.1f, 100.0f); //VBO -- Vertex Buffer Object static const GLfloat g_vertex_buffer_data[] = { -1.0f,-1.0f,-1.0f, // triangle 1 : begin -1.0f,-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, // triangle 1 : end 1.0f, 1.0f,-1.0f, // triangle 2 : begin -1.0f,-1.0f,-1.0f, -1.0f, 1.0f,-1.0f, // triangle 2 : end 1.0f,-1.0f, 1.0f, -1.0f,-1.0f,-1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 1.0f,-1.0f, 1.0f,-1.0f,-1.0f, -1.0f,-1.0f,-1.0f, -1.0f,-1.0f,-1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f,-1.0f, 1.0f,-1.0f, 1.0f, -1.0f,-1.0f, 1.0f, -1.0f,-1.0f,-1.0f, -1.0f, 1.0f, 1.0f, -1.0f,-1.0f, 1.0f, 1.0f,-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 1.0f,-1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 1.0f, 1.0f, 1.0f,-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,-1.0f, -1.0f, 1.0f,-1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f,-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f,-1.0f, 1.0f }; static GLfloat cube_red_buffer_data[12*3*3]; static GLfloat cube_blue_buffer_data[12*3*3]; for (int i = 0; i < 12*3; i++) { cube_red_buffer_data[i*3+0] = 1.0; cube_red_buffer_data[i*3+1] = 0.1; cube_red_buffer_data[i*3+2] = 0.1; cube_blue_buffer_data[i*3+0] = 0.1; cube_blue_buffer_data[i*3+1] = 0.1; cube_blue_buffer_data[i*3+2] = 1.0; } static const GLfloat cylVertexArray[] = { -1.000, 0.000, 0.000, -0.866, 0.500, 0.000, -0.500, 0.866, 0.000, -0.000, 1.000, 0.000, 0.500, 0.866, 0.000, 0.866, 0.500, 0.000, 1.000, -0.000, 0.000, 0.866, -0.500, 0.000, 0.500, -0.866, 0.000, 0.000, -1.000, 0.000, -0.500, -0.866, 0.000, -0.866, -0.500, 0.000, 1.000, 0.000, 1.000, 0.866, 0.500, 1.000, 0.500, 0.866, 1.000, 0.000, 1.000, 1.000, -0.500, 0.866, 1.000, -0.866, 0.500, 1.000, -1.000, -0.000, 1.000, -0.866, -0.500, 1.000, -0.500, -0.866, 1.000, -0.000, -1.000, 1.000, 0.500, -0.866, 1.000, 0.866, -0.500, 1.000, }; static const GLfloat cylIndexArray[] = { 1, 2, 3, 1, 3, 4, 1, 4, 5, 1, 5, 6, 1, 6, 7, 1, 7, 8, 1, 8, 9, 1, 9, 10, 1, 10, 11, 1, 11, 12, 13, 14, 15, 13, 15, 16, 13, 16, 17, 13, 17, 18, 13, 18, 19, 13, 19, 20, 13, 20, 21, 13, 21, 22, 13, 22, 23, 13, 23, 24, 24, 8, 7, 24, 7, 13, 21, 11, 10, 21, 10, 22, 23, 9, 8, 23, 8, 24, 20, 12, 11, 20, 11, 21, 22, 10, 9, 22, 9, 23, 19, 1, 12, 19, 12, 20, 18, 2, 1, 18, 1, 19, 14, 13, 7, 14, 7, 6, 15, 5, 4, 15, 4, 16, 17, 3, 2, 17, 2, 18, 15, 14, 6, 15, 6, 5, 16, 4, 3, 16, 3, 17, }; const int cylSize = 44*3*3; static GLfloat cyl_vertex_buffer_data[cylSize]; int index; for (int i = 0; i < cylSize/3; i++) { index = cylIndexArray[i]; cyl_vertex_buffer_data[i*3+0] = cylVertexArray[(index-1)*3+0]; cyl_vertex_buffer_data[i*3+1] = cylVertexArray[(index-1)*3+1]; cyl_vertex_buffer_data[i*3+2] = cylVertexArray[(index-1)*3+2]; } static GLfloat cyl_red_color_buffer_data[cylSize]; for (int i = 0; i < cylSize/3; i++) { cyl_red_color_buffer_data[i*3+0] = 0.8; //red cyl_red_color_buffer_data[i*3+1] = 0.1; //green cyl_red_color_buffer_data[i*3+2] = 0.1; //blue } static GLfloat cyl_white_color_buffer_data[cylSize]; for (int i = 0; i < cylSize/3; i++) { cyl_white_color_buffer_data[i*3+0] = 0.9; //red cyl_white_color_buffer_data[i*3+1] = 0.9; //green cyl_white_color_buffer_data[i*3+2] = 0.9; //blue } // Generate 1 buffer, put the resulting identifier in vertexBuffer glGenBuffers(1, &vertexBuffer); // The following commands will talk about our 'vertexBuffer' buffer glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); // Give our vertices to OpenGL. glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW); glGenBuffers(1, &cubeRedBuffer); glBindBuffer(GL_ARRAY_BUFFER, cubeRedBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(cube_red_buffer_data), cube_red_buffer_data, GL_STATIC_DRAW); glGenBuffers(1, &cubeBlueBuffer); glBindBuffer(GL_ARRAY_BUFFER, cubeBlueBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(cube_blue_buffer_data), cube_blue_buffer_data, GL_STATIC_DRAW); glGenBuffers(1, &cylinderBuffer); glBindBuffer(GL_ARRAY_BUFFER, cylinderBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(cyl_vertex_buffer_data), cyl_vertex_buffer_data, GL_STATIC_DRAW); glGenBuffers(1, &cylRedColorBuffer); glBindBuffer(GL_ARRAY_BUFFER, cylRedColorBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(cyl_red_color_buffer_data), cyl_red_color_buffer_data, GL_STATIC_DRAW); glGenBuffers(1, &cylWhiteColorBuffer); glBindBuffer(GL_ARRAY_BUFFER, cylWhiteColorBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(cyl_white_color_buffer_data), cyl_white_color_buffer_data, GL_STATIC_DRAW); }
void display(){ //setup of material values for light float m_amb[] = {0.23, 0.22, 0.23, 1.0}; float m_dif[] = {0.9, 0.9, 0.9, 1.0}; float m_spec[] = {0.1, 0.1, 0.1, 1.0}; float shiny = 1; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, m_amb); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, m_dif); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, m_spec); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shiny); glColorMaterial(GL_AMBIENT, GL_DIFFUSE); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); if(firstPersonMode==OFF && gamestatus==1){ gluLookAt(camPos[0], camPos[1], camPos[2], 0,10,0, 0,1,0); mainGame->draw(); }else if(gamestatus==1){ glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(450, 1, 1, 1000); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); mainGame->setFPLook(); mainGame->draw(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); mainGame->drawStrokeText((char*)"Score:", 400-180, 555); char* score = (char*)mainGame->setScore().c_str(); mainGame->drawStrokeText(score, 500-180, 555); mainGame->drawStrokeText((char*)"Balls Left:", 400-180, 525); char* ballLeft = (char*)mainGame->setBallsLeft().c_str(); mainGame->drawStrokeText(ballLeft, 550-180, 525); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glEnable(GL_TEXTURE_2D); }else if(gamestatus==0){ glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, 200, 0, 200); void * font1 = GLUT_BITMAP_TIMES_ROMAN_24; void * font2 = GLUT_BITMAP_9_BY_15; void * font3 = GLUT_BITMAP_TIMES_ROMAN_10; //Title glColor3f(1, 0, 0); glRasterPos2i(70, 170); string title = "WALL BLASTER"; for (string::iterator i = title.begin(); i != title.end(); ++i){ char c = *i; glutBitmapCharacter(font1, c); } //Instruction line 1 glColor3f(1, 1, 1); glRasterPos2i(15, 130); string desc1 = "CLICK TO FIRE BALLS. BREAK THE GLASS PLANES THAT COME AT YOU. IF YOU GET HIT BY ONE, YOU LOSE."; for (string::iterator i = desc1.begin(); i != desc1.end(); ++i){ char c = *i; glutBitmapCharacter(font3, c); } //Instruction line 2 glRasterPos2i(15, 120); string desc2 = "HITTING ONE OF THE MANY PYRAMIDS ON THE FLOOR WILL ADD THREE BALLS TO YOUR TOTAL BALL AMMO"; for (string::iterator i = desc2.begin(); i != desc2.end(); ++i){ char c = *i; glutBitmapCharacter(font3, c); } //S glRasterPos2i(80, 80); string start = "(S)"; for (string::iterator i = start.begin(); i != start.end(); ++i){ char c = *i; glutBitmapCharacter(font2, c); } //Q glRasterPos2i(80, 60); string quit = "(Q)"; for (string::iterator i = quit.begin(); i != quit.end(); ++i){ char c = *i; glutBitmapCharacter(font2, c); } //Start glColor3f(0, 0.5, 1); glRasterPos2i(90, 80); string start2 = "Start"; for (string::iterator i = start2.begin(); i != start2.end(); ++i){ char c = *i; glutBitmapCharacter(font2, c); } //Quit glRasterPos2i(90, 60); string quit2 = "Quit"; for (string::iterator i = quit2.begin(); i != quit2.end(); ++i){ char c = *i; glutBitmapCharacter(font2, c); } //Name glColor3f(1, 1, 1); glRasterPos2i(15, 10); string name = "BY: Simarpreet Singh (1216728), Birunthaa Umamahesan (1203142), Joseph Nguyen (1229287), Curran Tam (1231038)"; for (string::iterator i = name.begin(); i != name.end(); ++i){ char c = *i; glutBitmapCharacter(font3, c); } }else if(gamestatus == 2){ glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, 200, 0, 200); //Pause Menu glColor3f(1, 1, 1); glRasterPos2i(80, 100); string pause = "PAUSED"; void * font1 = GLUT_BITMAP_TIMES_ROMAN_24; for (string::iterator i = pause.begin(); i != pause.end(); ++i){ char c = *i; glutBitmapCharacter(font1, c); } //additional description glRasterPos2i(60, 70); void * font3 = GLUT_BITMAP_TIMES_ROMAN_10; string desc2 = "PRESS (S) TO RESTART THE GAME OR (Q) TO QUIT"; for (string::iterator i = desc2.begin(); i != desc2.end(); ++i){ char c = *i; glutBitmapCharacter(font3, c); } } else if(gamestatus == 3){ glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, 200, 0, 200); //GAMEOVER glColor3f(1, 0, 0); glRasterPos2i(80, 100); string gameover = "GAME OVER"; void * font1 = GLUT_BITMAP_TIMES_ROMAN_24; for (string::iterator i = gameover.begin(); i != gameover.end(); ++i){ char c = *i; glutBitmapCharacter(font1, c); } glRasterPos2i(20, 130); string gameover2 = "YOU HIT A GLASS OR RAN OUT OF BALLS!"; for (string::iterator i = gameover2.begin(); i != gameover2.end(); ++i){ char c = *i; glutBitmapCharacter(font1, c); } //additional description glColor3f(1, 1, 1); glRasterPos2i(60, 70); void * font3 = GLUT_BITMAP_TIMES_ROMAN_10; string desc2 = "PRESS (S) TO RESTART THE GAME OR (Q) TO QUIT"; for (string::iterator i = desc2.begin(); i != desc2.end(); ++i){ char c = *i; glutBitmapCharacter(font3, c); } } glFlush(); glutSwapBuffers(); }
void renderScene(void) { //Set up Viewport 1 scene // Use the Projection Matrix glMatrixMode(GL_PROJECTION); // Reset Matrix glLoadIdentity(); glScissor(0, 0, (GLsizei) windowWidth, (GLsizei) windowHeight*0.9); glEnable(GL_SCISSOR_TEST); glClearDepth(1.0); glClearColor(0.49f, 0.75f, 0.93f, 1.0f); // Set the viewport to be the entire window glViewport (0, 0, (GLsizei) windowWidth, (GLsizei) windowHeight*0.9); // Set the correct perspective. if (viewMode == PERSPECTIVE) gluPerspective(45.0f*zoom, ratio, 1.0f, 1000.0f); else if (viewMode == ORTHOGRAPHIC) glOrtho((-windowWidth/50)*zoom, (windowWidth/50)*zoom, (-windowHeight/50)*zoom, (windowHeight/50)*zoom, 1.0f, 1000); // Get Back to the Modelview glMatrixMode(GL_MODELVIEW); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Decide if wire frame or shaded if (polygonMode == WIREFRAME) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); else if (polygonMode == SHADED) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glLoadIdentity(); moveCamera(); lx = (sin(heliRot+PI)); lz = (cos(heliRot+PI)); float camX = curX + lx * 10.0f; float camZ = curZ + lz * 10.0f; //Set camera if (viewPerson == THIRD) { gluLookAt(eyeX+curX, eyeY, eyeZ+curZ, curX, 0.0f, curZ, upX, upY, upZ); } else if (viewPerson == FIRST) { gluLookAt(camX, 1.5f, camZ, camX+lx, 1.5f, camZ+lz, 0.0f, 1.0f, 0.0f); } glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); // smooth out lighting glEnable(GL_NORMALIZE); // normalize lighting GLfloat mat_specular[] = {0.3, 0.3, 0.3, 1.0}; GLfloat mat_shininess[] = { 10.0 }; glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); if (lightingEnabled) { glEnable(GL_LIGHTING); if (sunlight) { setSunlight(); } else { glDisable(GL_LIGHT0); } if (thirdPersonLight) { setThirdPersonLight(); } else { glDisable(GL_LIGHT3); } } else { glDisable(GL_LIGHTING); } glPushMatrix(); glTranslatef(0.0f, -10, 0.0f); drawGround(250, 100); glPopMatrix(); glPushMatrix(); glTranslatef(0.0f, -9.9, 0.0f); drawTrack(100.0, 100.0); glPopMatrix(); glPushMatrix(); moveHelicopter(); glRotatef(heliRot/PI*180, 0.0f, 1.0f, 0.0f); drawHelicopter(); if (lightingEnabled) { if (circleLight) { moveLight(); setCircularLight(); } else { glDisable(GL_LIGHT2); } } glPopMatrix(); //Set up Viewport 2 scene // Use the Projection Matrix glMatrixMode(GL_PROJECTION); // Reset Matrix glLoadIdentity(); glScissor(0, windowHeight*0.9, (GLsizei) windowWidth, (GLsizei) windowHeight*0.1); glEnable(GL_SCISSOR_TEST); glClearDepth(1.0); glClearColor(1, 1, 1, 1); // Set the viewport to be the entire window glViewport (0, windowHeight*0.9, (GLsizei) windowWidth, (GLsizei) windowHeight*0.1); // Set the correct perspective. // Get Back to the Modelview glMatrixMode(GL_MODELVIEW); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); frame++; time=glutGet(GLUT_ELAPSED_TIME); if (time - timebase > 1000) { sprintf(s,"FPS:%4.2f", frame*1000.0/(time-timebase)); timebase = time; frame = 0; } glColor3f(0.0f,0.0f,0.0f); glPushMatrix(); glLoadIdentity(); setOrthographicProjection(); glTranslatef(100.0f, 150, 0.0f); renderBitmapString(5,30,0,GLUT_BITMAP_HELVETICA_18,s); glPopMatrix(); restorePerspectiveProjection(); glutSwapBuffers(); }
void GameManager::display(){ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(_cameraLook!=1){ if(_cameraLook==3) updateThirdCameraView(); _camera->computeVisualizationMatrix(_eyePosition->getX(), _eyePosition->getY(), _eyePosition->getZ(), _targetPosition->getX(), _targetPosition->getY(), _targetPosition->getZ(), _upVector->getX(), _upVector->getY(), _upVector->getZ()); } glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); //specifies which material parameters track the current color glEnable(GL_NORMALIZE); glPushMatrix(); std::list<StaticObject*>::iterator object=_game_objects.begin(); (*object)->draw(tex_water); object++; (*object)->draw(tex_riverside); object++; (*object)->draw(tex_road); object++; (*object)->draw(tex_roadside); object++; for(std::list<TimberLog*>::iterator object=_timberLogs.begin(); object != _timberLogs.end(); object++){ (*object)->draw(tex_timberlog); } _frog->draw(tex_frog); for(std::list<DynamicObject*>::iterator object=_cars.begin(); object != _cars.end(); object++){ (*object)->draw(); } for(int i=0; i<6; i++){ _lightPosts[i]->drawLightPost(); _lightPosts[i]->shine(); } _mainAmbientLight->shine(); updateHeadLightPosition(); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); _vidasCamera->computeProjectionMatrix(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); if(_paused){ _message->draw(tex_pause); } else if (_gameOver){ _message->draw(tex_game_over); } for(int i=0; i<_vidas; i++){ _vida->draw(i, tex_frog, tex_eye); } glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glutSwapBuffers(); }
bool HGE_Impl::_GfxInit() { // static const char *szFormats[]={"UNKNOWN", "R5G6B5", "X1R5G5B5", "A1R5G5B5", "X8R8G8B8", "A8R8G8B8"}; // D3DADAPTER_IDENTIFIER9 AdID; // D3DDISPLAYMODE Mode; // D3DFORMAT Format=D3DFMT_UNKNOWN; // UINT nModes, i; // Init Open GL /* HDC hDC; HGLRC hRC; long gl_error; hDC = GetDC(pHGE->hwnd); hRC = wglCreateContext(hDC); if (hRC == NULL) { System_Log("Creating GL Context Failed with error code: %d", GetLastError()); return false; } System_Log("Initializing Graphix"); wglMakeCurrent(hDC, hRC); */ long gl_error; GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ System_Log("GLEW init Error: %s\n", glewGetErrorString(err)); } else System_Log("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); if (!GLEW_EXT_framebuffer_object) { System_Log("Status: Unavailable Extension GL_EXT_framebuffer_object\n"); } else System_Log("Status: GL_EXT_framebuffer_object is supportet\n"); glShadeModel(GL_SMOOTH); // Enables Smooth Shading glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // 4-byte pixel alignment glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearStencil(0); // clear stencil buffer glClearDepth(1.0f); // Depth Buffer Setup glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); // glCullFace(GL_BACK); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); // glDisable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations // Get adapter info System_Log("OpenGL version: %s", glGetString( GL_VERSION )); // System_Log("OpenGL version: %s", glGetString( GL_EXTENSIONS )); // Set up Full Screen presentation parameters _AdjustWindow(); System_Log("Mode: width = %d height = %d\n",nScreenWidth,nScreenHeight); // Create vertex batch buffer textures=0; // Init all stuff that can be lost _SetProjectionMatrix(nScreenWidth, nScreenHeight); if (GL_ERROR(gl_error)) { System_Log("OpenGL error: %d", gl_error); return false; } if(!_init_lost()) return false; Gfx_Clear(0); System_Log("Graphix initialized"); return true; }
int main(int argc,char** args) { srand(time(NULL)); try { if (SDL_Init(SDL_INIT_VIDEO)) { fprintf(stderr,"Unable to initialize SDL: %s\n",SDL_GetError()); return EXIT_FAILURE; } atexit(SDL_Quit); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1); #if 0 screen = SDL_SetVideoMode(1440,900,32,SDL_OPENGL|SDL_FULLSCREEN); #else screen = SDL_SetVideoMode(1024,768,32,SDL_OPENGL/*|SDL_FULLSCREEN*/); #endif if(!screen) { fprintf(stderr,"Unable to create SDL screen: %s\n",SDL_GetError()); return EXIT_FAILURE; } SDL_WM_SetCaption("GlestNG","GlestNG"); GLenum err = glewInit(); if(GLEW_OK != err) { fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); return EXIT_FAILURE; } fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); // we have a GL context so we can go ahead and init all the singletons std::auto_ptr<fs_t> fs_settings(fs_t::create("data/")); fs_t::settings = fs_settings.get(); // set it globally std::auto_ptr<xml_parser_t> xml_settings(new xml_parser_t("UI Settings",fs_settings->get_body("ui_settings.xml"))); xml_settings->set_as_settings(); std::auto_ptr<graphics_t::mgr_t> graphics_mgr(graphics_t::create()); std::auto_ptr<fonts_t> fonts(fonts_t::create()); std::auto_ptr<fs_t> fs; try { fs.reset(fs_t::create("data/Glest")); if(false) { fs_file_t::ptr_t logo_file(fs_settings->get("logo.g3d")); istream_t::ptr_t logostream(logo_file->reader()); logo = std::auto_ptr<model_g3d_t>(new model_g3d_t(*logostream)); } load(*fs); } catch(glest_exception_t* e) { std::cerr << "cannot load glest data: " << e << std::endl; delete e; } std::auto_ptr<ui_mgr_t> ui_(ui_mgr()); std::auto_ptr<mod_ui_t> mod_ui(mod_ui_t::create()); std::auto_ptr<terrain_t> terrain(terrain_t::gen_planet(5,500,3)); //world()->dump(std::cout); v4_t light_amb(0,0,0,1), light_dif(1.,1.,1.,1.), light_spec(1.,1.,1.,1.), light_pos(1.,1.,-1.,0.), mat_amb(.7,.7,.7,1.), mat_dif(.8,.8,.8,1.), mat_spec(1.,1.,1.,1.); glLightfv(GL_LIGHT0,GL_AMBIENT,light_amb.v); glLightfv(GL_LIGHT0,GL_DIFFUSE,light_dif.v); glLightfv(GL_LIGHT0,GL_SPECULAR,light_spec.v); glLightfv(GL_LIGHT0,GL_POSITION,light_pos.v); glLightfv(GL_LIGHT1,GL_AMBIENT,light_amb.v); glLightfv(GL_LIGHT1,GL_DIFFUSE,light_dif.v); glLightfv(GL_LIGHT1,GL_SPECULAR,light_spec.v); glMaterialfv(GL_FRONT,GL_AMBIENT,mat_amb.v); glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_dif.v); glMaterialfv(GL_FRONT,GL_SPECULAR,mat_spec.v); glMaterialf(GL_FRONT,GL_SHININESS,100.0); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glAlphaFunc(GL_GREATER,0.4); glEnable(GL_COLOR_MATERIAL); glEnable(GL_RESCALE_NORMAL); glEnable(GL_BLEND); glEnable(GL_TEXTURE_2D); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glEnable(GL_NORMALIZE); glFrontFace(GL_CW); camera(); bool quit = false; SDL_Event event; SDL_EnableKeyRepeat(200,20); SDL_EnableUNICODE(true); const unsigned start = SDL_GetTicks(); framerate.reset(); while(!quit) { set_now(SDL_GetTicks()-start); while(!quit && SDL_PollEvent(&event)) { if(ui_mgr()->offer(event)) continue; switch (event.type) { case SDL_MOUSEMOTION: if(selection) std::cout << "drag" << std::endl; /*printf("Mouse moved by %d,%d to (%d,%d)\n", event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y);*/ break; case SDL_MOUSEBUTTONDOWN: click(event.button.x,event.button.y); if(selection) std::cout << "selection: "<<selected_point<<std::endl; break; case SDL_MOUSEBUTTONUP: if(selection) std::cout << "selection stopped" << std::endl; selection = false; break; case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_PLUS: zoom += 1; camera(); break; case SDLK_MINUS: zoom -= 1; camera(); break; case SDLK_ESCAPE: quit = true; break; case SDLK_m: // MODDING MODE if(!fs.get()) { std::cerr << "(modding menu triggered but mod not loaded)" << std::endl; break; } if(mod_ui->is_shown()) mod_ui->hide(); else mod_ui->show(ref_t(*techtree,TECHTREE,techtree->name)); break; default: std::cout << "Ignoring key " << (int)event.key.keysym.scancode << "," << event.key.keysym.sym << "," << event.key.keysym.mod << "," << event.key.keysym.unicode << std::endl; } break; case SDL_QUIT: quit = true; break; } } framerate.tick(now()); tick(); } for(tests_t::iterator i=objs.begin(); i!=objs.end(); i++) delete *i; return EXIT_SUCCESS; } catch(data_error_t* de) { std::cerr << "Oh! " << de << std::endl; } catch(graphics_error_t* ge) { std::cerr << "Oh! " << ge << std::endl; } catch(panic_t* panic) { std::cerr << "Oh! " << panic << std::endl; } return EXIT_FAILURE; }
static void cubemodelPaintInside (CompScreen *s, const ScreenPaintAttrib *sAttrib, const CompTransform *transform, CompOutput *output, int size) { int i; static const float matShininess[] = { 60.0 }; static const float matSpecular[] = { 0.6, 0.6, 0.6, 1.0 }; static const float matDiffuse[] = { 1.0, 1.0, 1.0, 1.0 }; static const float matAmbient[] = { 0.8, 0.8, 0.9, 1.0 }; static const float lmodelLocalviewer[] = { 0.0 }; static float lmodelTwoside[] = { 0.0 }; static float lmodelAmbient[] = { 0.4, 0.4, 0.4, 0.4 }; static float lmodelDiffuse[] = { 1.0, 1.0, 1.0, 1.0 }; static float lmodelSpecular[]= { 0.6, 0.6, 0.6, 0.6 }; ScreenPaintAttrib sA = *sAttrib; CompTransform mT = *transform; Bool enabledCull; int cull; float scale, outputRatio = 1.0f; CUBEMODEL_SCREEN (s); CUBE_SCREEN (s); if (cms->hsize != s->hsize * cs->nOutput) { initWorldVariables (s); updateModel (s, 0, cms->numModels); } sA.yRotate += cs->invert * (360.0f / size) * (cs->xRotations - (s->x* cs->nOutput)); (*s->applyScreenTransform) (s, &sA, output, &mT); glPushMatrix (); if (cubemodelGetRotateLighting (s)) setLightPosition (s, GL_LIGHT1); glLoadMatrixf (mT.m); if (!cubemodelGetRotateLighting (s)) setLightPosition (s, GL_LIGHT1); glTranslatef (cs->outputXOffset, -cs->outputYOffset, 0.0f); glScalef (cs->outputXScale, cs->outputYScale, 1.0f); glPushAttrib (GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT | GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT); glEnable (GL_BLEND); glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); lmodelAmbient[0] = cubemodelGetLightAmbient (s); lmodelDiffuse[0] = cubemodelGetLightDiffuse (s); lmodelSpecular[0] = cubemodelGetLightSpecular (s); for (i = 1; i < 4; i++) { lmodelAmbient[i] = lmodelAmbient[0]; lmodelDiffuse[i] = lmodelDiffuse[0]; lmodelSpecular[i] = lmodelSpecular[0]; } lmodelTwoside[0] = (cubemodelGetRenderFrontAndBack (s) ? 1.0f : 0.0f); glLightModelfv (GL_LIGHT_MODEL_LOCAL_VIEWER, lmodelLocalviewer); glLightModelfv (GL_LIGHT_MODEL_TWO_SIDE, lmodelTwoside); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lmodelAmbient); glLightfv (GL_LIGHT1, GL_DIFFUSE, lmodelDiffuse); glLightfv (GL_LIGHT1, GL_SPECULAR, lmodelSpecular); enabledCull = glIsEnabled (GL_CULL_FACE); glGetIntegerv (GL_CULL_FACE_MODE, &cull); glEnable (GL_CULL_FACE); glCullFace (~cull & (GL_FRONT | GL_BACK)); glCullFace (cull); glPushMatrix (); glColor4usv (defaultColor); glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, matShininess); glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular); glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, matDiffuse); glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, matAmbient); glEnable (GL_NORMALIZE); glEnable (GL_DEPTH_TEST); glEnable (GL_COLOR_MATERIAL); glEnable (GL_LIGHTING); glEnable (GL_LIGHT1); glDisable (GL_LIGHT0); glDepthFunc (GL_LEQUAL); /* for transparency maps */ glShadeModel(GL_SMOOTH); glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); scale = cs->distance; if (cubemodelGetRescaleWidth (s)) { if (cs->moMode == CUBE_MOMODE_AUTO && cs->nOutput < s->nOutputDev) outputRatio = (float) s->width / (float) s->height; else outputRatio = (float) output->width / (float) output->height; } glScalef (scale / outputRatio, scale, scale / outputRatio); glPushMatrix (); glColor4f (1.0, 1.0, 1.0, 1.0); for (i = 0; i < cms->numModels; i++) { glPushMatrix (); cubemodelDrawModelObject (s, cms->models[i], cubemodelGetGlobalModelScaleFactor (s)); glPopMatrix (); } glPopMatrix (); glPopMatrix (); glDisable (GL_LIGHT1); glDisable (GL_NORMALIZE); if (!s->lighting) glDisable (GL_LIGHTING); glDisable (GL_DEPTH_TEST); if (enabledCull) glDisable (GL_CULL_FACE); glPopMatrix (); glPopAttrib (); cms->damage = TRUE; UNWRAP (cms, cs, paintInside); (*cs->paintInside) (s, sAttrib, transform, output, size); WRAP (cms, cs, paintInside, cubemodelPaintInside); }
// Draw our world void display(void) { int ix, iy; int i; int j; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Clear the screen glMatrixMode (GL_PROJECTION); // Tell opengl that we are doing project matrix work glLoadIdentity(); // Clear the matrix glOrtho(-9.0, 9.0, -9.0, 9.0, 0.0, 30.0); // Setup an Ortho view glMatrixMode(GL_MODELVIEW); // Tell opengl that we are doing model matrix work. (drawing) glLoadIdentity(); // Clear the model matrix glDisable(GL_COLOR_MATERIAL); glDisable(GL_LIGHTING); glColor3f(1.0, 0.0, 0.0); if ( start_game == 0 ) { Sprint(-2, 1, "\nTIC TAC TOE"); Sprint(-2, -2, "To Start press"); Sprint(-2, -3, "right button for X's"); Sprint(-2, -4, "and left for O's"); } if (win == 1) Sprint( -2, 1, "\nYou win "); if (win == -1) Sprint( -2, 1, "\n\n\nComputer win "); if (win == 2) Sprint( -2, 1, "\nTie"); // Setup view, and print view state on screen if (view_state == 1) { glColor3f( 0.0, 0.0, 1.0); Sprint(-3, 8, "Perspective view"); glMatrixMode (GL_PROJECTION); glLoadIdentity(); gluPerspective(60, 1, 1, 30); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } else { glColor3f( 0.0, 0.0, 1.0); // Sprint(-2, 8, "Ortho view"); } // Lighting on/off if (light_state == 1) { glDisable(GL_LIGHTING); glDisable(GL_COLOR_MATERIAL); }else { glEnable(GL_LIGHTING); glEnable(GL_COLOR_MATERIAL); } gluLookAt( 0, 0, 20, 0, 0, 0, 0, 1, 0); // Draw Grid for( ix = 0; ix < 4; ix++) { glPushMatrix(); glColor3f(1,1,1); glBegin(GL_LINES); glVertex2i(-9 , -9 + ix * 6); glVertex2i(9 , -9 + ix * 6 ); glEnd(); glPopMatrix(); } for( iy = 0; iy < 4; iy++ ) { glPushMatrix(); glColor3f(1,1,1); glBegin(GL_LINES); glVertex2i(-9 + iy * 6, 9 ); glVertex2i(-9 + iy * 6, -9 ); glEnd(); glPopMatrix(); } glColorMaterial(GL_FRONT, GL_AMBIENT); glColor4f(0.0, 0.0, 1.0, 1.0); glColorMaterial(GL_FRONT, GL_EMISSION); glColor4f(0.1, 0.0, 0.0, 1.0 ); glColorMaterial(GL_FRONT, GL_SPECULAR); glColor4f(0.35, 0.35, 0.35, 1.0); glColorMaterial(GL_FRONT, GL_DIFFUSE); glColor4f(0.69, 0.69, 0.69, 1.0); //glDisable(GL_COLOR_MATERIAL); glColor3f( 1.0, 0.0, 1.0); // Cube color //glEnable(GL_COLOR_MATERIAL); // Draw object in box's for( i = 0; i < 9; i++) { j = 0; if (abs( win ) == 1 ) { if ( (i == box[spinboxes][0]) || (i == box[spinboxes][1]) || (i == box[spinboxes][2])) { j = spin; }else j = 0; } if(box_map[i] == 1) Draw_X( object_map[i][0], object_map[i][1], -1, j); if(box_map[i] == -1) Draw_O( object_map[i][0], object_map[i][1], -1, j); } //glDisable(GL_COLOR_MATERIAL); glutSwapBuffers(); }
void hwColorPerVertexShader::drawTheSwatch( MGeometryData* pGeomData, unsigned int* pIndexing, unsigned int numberOfData, unsigned int indexCount ) { MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer(); if( !pRenderer ) return; // Set the default background color { float r, g, b, a; MHWShaderSwatchGenerator::getSwatchBackgroundColor( r, g, b, a ); glClearColor( r, g, b, a ); } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); { // Enable the blending to get the transparency to work // glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } // Load in a sample background image if (mSampleImageId == 0) { mSampleImage = new MImage; MStatus rstatus = mSampleImage->readFromFile("C:\\temp\\maya.gif"); if (rstatus == MStatus::kSuccess) { unsigned int w, h; mSampleImage->getSize( w, h ); if (w > 2 && h > 2 ) { glGenTextures( 1, &mSampleImageId ); if (mSampleImageId > 0) { glEnable(GL_TEXTURE_2D); glBindTexture ( GL_TEXTURE_2D, mSampleImageId ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) mSampleImage->pixels() ); } } } if (mSampleImage) { delete mSampleImage; } } // Overlay the background checker board // bool drawBackGround = ( mTranspBias > 0.0f ); bool drawBackGroundTexture = (mSampleImageId != 0); if (drawBackGround) { if (drawBackGroundTexture) { glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glBindTexture(GL_TEXTURE_2D, mSampleImageId ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glEnable(GL_TEXTURE_2D); } unsigned int numberOfRepeats = 8; MColor quadColor( 0.5f, 0.5f, 0.5f, 1.0f ); pRenderer->drawSwatchBackGroundQuads( quadColor, drawBackGroundTexture, numberOfRepeats ); if (drawBackGroundTexture) glDisable(GL_TEXTURE_2D); glEnable(GL_LIGHTING); } { // Set some example material // float ambient[4] = { 0.1f, 0.1f, 0.1f, 1.0f }; float diffuse[4] = { 0.7f, 0.7f, 0.7f, 1.0f }; float specular[4] = { 0.5f, 0.5f, 0.5f, 1.0f }; float emission[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission ); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular ); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0f); // Track diffuse color float swatchColor[4]; float biasT = 1.0f - mTranspGain - mTranspBias; swatchColor[0] = (diffuse[0] * mColorGain[0]) + mColorBias[0]; swatchColor[1] = (diffuse[1] * mColorGain[1]) + mColorBias[1]; swatchColor[2] = (diffuse[2] * mColorGain[2]) + mColorBias[2]; swatchColor[3] = (diffuse[3] * mTranspGain) + biasT; glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, swatchColor ); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glColor4fv( swatchColor ); } if (pGeomData) { glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT ); if (mNormalsPerVertex >= 1) { glDisable(GL_LIGHTING); float *normalData = (float *)( pGeomData[1].data() ); float * tangentData = (float *)( pGeomData[3].data() ); float * binormalData = (float *)( pGeomData[4].data() ); if (normalData && mNormalsPerVertex == 1) { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(3, GL_FLOAT, 0, normalData); } else if (tangentData && mNormalsPerVertex == 2) { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(3, GL_FLOAT, 0, tangentData); } else if (binormalData) { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(3, GL_FLOAT, 0, binormalData); } } float *vertexData = (float *)( pGeomData[0].data() ); if (vertexData) { glEnableClientState( GL_VERTEX_ARRAY ); glVertexPointer ( 3, GL_FLOAT, 0, vertexData ); } float *normalData = (float *)( pGeomData[1].data() ); if (normalData) { glEnableClientState( GL_NORMAL_ARRAY ); glNormalPointer ( GL_FLOAT, 0, normalData ); } if (mSampleImageId > 0) { float *uvData = (float *) (pGeomData[2].data() ); if (uvData) { glBindTexture ( GL_TEXTURE_2D, mSampleImageId ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glEnable(GL_TEXTURE_2D); glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glTexCoordPointer( 2, GL_FLOAT, 0, uvData ); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glScalef( 0.5f, 0.5f, 1 ); //glTranslatef(0.5f, 0.5f, 0.0f); glRotatef( mTexRotateX, 1.0f, 0.0f, 0.0f); glRotatef( mTexRotateY, 0.0, 1.0f, 0.0f); glRotatef( mTexRotateZ, 0.0, 0.0f, 1.0f); glMatrixMode(GL_MODELVIEW); } } if (vertexData && normalData && pIndexing ) glDrawElements ( GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, pIndexing ); glPopClientAttrib(); // Release data references pRenderer->dereferenceGeometry( pGeomData, numberOfData ); } glDisable( GL_COLOR_MATERIAL ); glDisable( GL_LIGHTING ); }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(500, 500); glutCreateWindow("Newave"); if (argc > 1 && argv[1] != 0) texFilename1 = argv[1]; if (argc > 2 && argv[2] != 0) texFilename2 = argv[2]; glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glClearColor(0.0, 0.0, 0.0, 0.0); glPolygonOffset(1.0, 1.0); glEnable(GL_CULL_FACE); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_DIFFUSE); glLightfv (GL_LIGHT0, GL_POSITION, lightPosition); glEnable(GL_LIGHT0); loadImageTexture(); setSize(MEDIUM); setSpeed(NORMAL); setDisplay(TEXTURED); setOther(ENVMAP); reset(HILLFOUR); glutReshapeFunc(reshape); glutDisplayFunc(display); glutVisibilityFunc(visibility); glutKeyboardFunc(keyboard); glutMouseFunc(mouse); glutMotionFunc(motion); displayMenu = glutCreateMenu(setDisplay); glutAddMenuEntry("Wireframe", WIREFRAME); glutAddMenuEntry("Hidden Line", HIDDENLINE); glutAddMenuEntry("Flat Shaded", FLATSHADED); glutAddMenuEntry("Smooth Shaded", SMOOTHSHADED); glutAddMenuEntry("Textured", TEXTURED); otherMenu = glutCreateMenu(setOther); glutAddMenuEntry("Full Screen", FULLSCREEN); glutAddMenuEntry("Face Normals", FACENORMALS); glutAddMenuEntry("Antialias", ANTIALIAS); glutAddMenuEntry("Environment Map", ENVMAP); speedMenu = glutCreateMenu(setSpeed); glutAddMenuEntry("Weak", WEAK); glutAddMenuEntry("Normal", NORMAL); glutAddMenuEntry("Strong", STRONG); sizeMenu = glutCreateMenu(setSize); glutAddMenuEntry("Small", SMALL); glutAddMenuEntry("Medium", MEDIUM); glutAddMenuEntry("Large", LARGE); glutAddMenuEntry("Extra Large", XLARGE); resetMenu = glutCreateMenu(reset); glutAddMenuEntry("Current", CURRENT); glutAddMenuEntry("Spike", SPIKE); glutAddMenuEntry("Hole", HOLE); glutAddMenuEntry("Diagonal Wall", DIAGONALWALL); glutAddMenuEntry("Side Wall", SIDEWALL); glutAddMenuEntry("Middle Block", MIDDLEBLOCK); glutAddMenuEntry("Diagonal Block", DIAGONALBLOCK); glutAddMenuEntry("Corner Block", CORNERBLOCK); glutAddMenuEntry("Hill", HILL); glutAddMenuEntry("Hill Four", HILLFOUR); mainMenu = glutCreateMenu(setMain); glutAddMenuEntry("Go", 2); glutAddMenuEntry("Stop", 3); glutAddMenuEntry("Reverse", 4); glutAddSubMenu("Display", displayMenu); glutAddSubMenu("Reset", resetMenu); glutAddSubMenu("Size", sizeMenu); glutAddSubMenu("Speed", speedMenu); glutAddSubMenu("Other", otherMenu); glutAddMenuEntry("Exit", 5); glutAttachMenu(GLUT_RIGHT_BUTTON); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }
// this is the code that actually draws the window // it puts a lot of the work into other routines to simplify things void TrainView::draw() { glViewport(0,0,w(),h()); // clear the window, be sure to clear the Z-Buffer too glClearColor(0,0,.3f,0); // background should be blue // we need to clear out the stencil buffer since we'll use // it for shadows glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glEnable(GL_DEPTH); // Blayne prefers GL_DIFFUSE glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); // prepare for projection glMatrixMode(GL_PROJECTION); glLoadIdentity(); setProjection(); // put the code to set up matrices here // TODO: you might want to set the lighting up differently // if you do, // we need to set up the lights AFTER setting up the projection // enable the lighting glEnable(GL_COLOR_MATERIAL); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // top view only needs one light if (tw->topCam->value()) { glDisable(GL_LIGHT1); glDisable(GL_LIGHT2); } else { glEnable(GL_LIGHT1); glEnable(GL_LIGHT2); } // set the light parameters GLfloat lightPosition1[] = {0,1,1,0}; // {50, 200.0, 50, 1.0}; GLfloat lightPosition2[] = {1, 0, 0, 0}; GLfloat lightPosition3[] = {0, -1, 0, 0}; GLfloat yellowLight[] = {0.5f, 0.5f, .1f, 1.0}; GLfloat whiteLight[] = {1.0f, 1.0f, 1.0f, 1.0}; GLfloat blueLight[] = {.1f,.1f,.3f,1.0}; GLfloat grayLight[] = {.3f, .3f, .3f, 1.0}; glLightfv(GL_LIGHT0, GL_POSITION, lightPosition1); glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteLight); glLightfv(GL_LIGHT0, GL_AMBIENT, grayLight); glLightfv(GL_LIGHT1, GL_POSITION, lightPosition2); glLightfv(GL_LIGHT1, GL_DIFFUSE, yellowLight); glLightfv(GL_LIGHT2, GL_POSITION, lightPosition3); glLightfv(GL_LIGHT2, GL_DIFFUSE, blueLight); // now draw the ground plane setupFloor(); glDisable(GL_LIGHTING); drawFloor(200,10); glEnable(GL_LIGHTING); setupObjects(); // we draw everything twice - once for real, and then once for // shadows drawStuff(); // this time drawing is for shadows (except for top view) if (!tw->topCam->value()) { setupShadows(); drawStuff(true); unsetupShadows(); } }
void ccOctree::RenderOctreeAs( CC_OCTREE_DISPLAY_TYPE octreeDisplayType, ccOctree* theOctree, unsigned char level, ccGenericPointCloud* theAssociatedCloud, int &octreeGLListID, bool updateOctreeGLDisplay) { if (!theOctree || !theAssociatedCloud) return; glPushAttrib(GL_LIGHTING_BIT); if (octreeDisplayType == WIRE) { //cet affichage demande trop de memoire pour le stocker sous forme de liste OpenGL //donc on doit le generer dynamiquement glDisable(GL_LIGHTING); //au cas où la lumiere soit allumee ccGL::Color3v(ccColor::green.rgba); void* additionalParameters[] = { theOctree->m_frustrumIntersector }; theOctree->executeFunctionForAllCellsAtLevel( level, &DrawCellAsABox, additionalParameters); } else { glDrawParams glParams; theAssociatedCloud->getDrawingParameters(glParams); if (glParams.showNorms) { //DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version is sometimes 1.0! glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, CC_DEFAULT_CLOUD_AMBIENT_COLOR.rgba ); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, CC_DEFAULT_CLOUD_SPECULAR_COLOR.rgba ); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, CC_DEFAULT_CLOUD_DIFFUSE_COLOR.rgba ); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, CC_DEFAULT_CLOUD_EMISSION_COLOR.rgba ); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, CC_DEFAULT_CLOUD_SHININESS); glEnable(GL_LIGHTING); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); } if (!glParams.showColors) ccGL::Color3v(ccColor::white.rgba); if (updateOctreeGLDisplay || octreeGLListID < 0) { if (octreeGLListID < 0) octreeGLListID = glGenLists(1); else if (glIsList(octreeGLListID)) glDeleteLists(octreeGLListID,1); glNewList(octreeGLListID,GL_COMPILE); if (octreeDisplayType == MEAN_POINTS) { void* additionalParameters[2] = { reinterpret_cast<void*>(&glParams), reinterpret_cast<void*>(theAssociatedCloud), }; glBegin(GL_POINTS); theOctree->executeFunctionForAllCellsAtLevel( level, &DrawCellAsAPoint, additionalParameters); glEnd(); } else { //by default we use a box as primitive PointCoordinateType cs = theOctree->getCellSize(level); CCVector3 dims(cs,cs,cs); ccBox box(dims); box.showColors(glParams.showColors || glParams.showSF); box.showNormals(glParams.showNorms); //trick: replace all normal indexes so that they point on the first one { if (box.arePerTriangleNormalsEnabled()) for (unsigned i=0;i<box.size();++i) box.setTriangleNormalIndexes(i,0,0,0); } //fake context CC_DRAW_CONTEXT context; context.flags = CC_DRAW_3D | CC_DRAW_FOREGROUND| CC_LIGHT_ENABLED; context._win = 0; void* additionalParameters[4] = { reinterpret_cast<void*>(&glParams), reinterpret_cast<void*>(theAssociatedCloud), reinterpret_cast<void*>(&box), reinterpret_cast<void*>(&context) }; theOctree->executeFunctionForAllCellsAtLevel( level, &DrawCellAsAPrimitive, additionalParameters); } glEndList(); } glCallList(octreeGLListID); if (glParams.showNorms) { glDisable(GL_COLOR_MATERIAL); glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glDisable(GL_LIGHTING); } } glPopAttrib(); }
int Terrain::Create(float xOffset, float yOffset, float zOffset) { GLuint terrainDL; float startW,startL; GLuint texName = LoadTextures(); startW = width / 2.0 - width; startL = - length / 2.0 + length; terrainDL = glGenLists(1); glNewList(terrainDL,GL_COMPILE); if (normals != NULL && colors != NULL) { glColorMaterial(GL_FRONT, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); } for (int i = 0 ; i < length-1; i++) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texName); /*glBegin(GL_QUADS); glTexCoord2f(1, 0); glVertex3f(10, 80, 0); glTexCoord2f(1, 1); glVertex3f(10, 90, 0); glTexCoord2f(0, 1); glVertex3f(0, 90, 0); glTexCoord2f(0, 0); glVertex3f(0, 80, 0); glEnd();*/ glBegin(GL_TRIANGLE_STRIP); for (int j = 0;j < width; j++) { if (colors != NULL) glColor3f(colors[3*((i+1)*width + j)], colors[3*((i+1)*width + j)+1], colors[3*((i+1)*width + j)+2]); if (normals != NULL) glNormal3f(normals[3*((i+1)*width + j)], normals[3*((i+1)*width + j)+1], normals[3*((i+1)*width + j)+2]); if (colors != NULL) glColor3f(colors[3*(i*width + j)], colors[3*(i*width + j)+1], colors[3*(i*width + j)+2]); if (normals != NULL) glNormal3f(normals[3*(i*width + j)], normals[3*(i*width + j)+1], normals[3*(i*width + j)+2]); glTexCoord2f((i+1) / 512.0, j / 512.0); glVertex3f(startW + j + xOffset, heights[(i+1)*width + (j)] + yOffset, startL - (i+1) + zOffset); glTexCoord2f(i / 512.0, j / 512.0); glVertex3f(startW + j + xOffset, heights[(i)*width + j] + yOffset, startL - i + zOffset); } glEnd(); glDisable(GL_TEXTURE_2D); } glEndList(); return(terrainDL); }
void GLContext::Invoke( const Message &msg ) { for ( Message::message_t::const_iterator &it = msg.m_message.begin(); it != msg.m_message.end(); ++it ) { unsigned int size = (*it).m_int; int opcode = (*++it).m_int; switch( opcode ) { // Transformation case MATRIX_MODE: assert( size == 3 ); { int mode = ToGLFlag( (*++it).m_int ); glMatrixMode( mode ); } break; case PUSH_MATRIX: assert( size == 2 ); { glPushMatrix(); } break; case POP_MATRIX: assert( size == 2 ); { glPopMatrix(); } break; case LOAD_IDENTITY: assert( size == 2 ); { glLoadIdentity(); } break; case LOAD_MATRIX: assert( size == 18 ); { float x[16]; for ( int i=0; i<16; ++i ) { x[i] = (*++it).m_float; } glLoadMatrixf( x ); } break; case MULT_MATRIX: assert( size == 18 ); { float x[16]; for ( int i=0; i<16; ++i ) { x[i] = (*++it).m_float; } glMultMatrixf( x ); } break; case TRANSLATE: assert( size == 5 ); { float x = (*++it).m_float; float y = (*++it).m_float; float z = (*++it).m_float; glTranslatef( x, y ,z ); } break; case ROTATE: assert( size == 6 ); { float angle = (*++it).m_float; float x = (*++it).m_float; float y = (*++it).m_float; float z = (*++it).m_float; glRotatef( angle, x ,y ,z ); } break; case SCALE: assert( size == 5 ); { float x = (*++it).m_float; float y = (*++it).m_float; float z = (*++it).m_float; glScalef( x, y ,z ); } break; // Blocks case BLOCK_BEGIN: { m_restoreVector.push_back( Message() ); } break; case BLOCK_END: { Restore(); m_restoreVector.pop_back(); } break; case SAVE: assert( size == 3 ); { int flag = (*++it).m_int; Save( flag ); } break; case SAVE_LIGHT: assert( size == 4 ); { int light = (*++it).m_int; int flag = (*++it).m_int; SaveLight( light, flag ); } break; case SAVE_MATERIAL: assert( size == 4 ); { int face = (*++it).m_int; int flag = (*++it).m_int; SaveMaterial( face, flag ); } break; // State case ENABLE: assert( size == 3 ); { int flag = (*++it).m_int; glEnable( ToGLFlag( flag )); } break; case DISABLE: assert( size == 3 ); { int flag = (*++it).m_int; glDisable( ToGLFlag( flag )); } break; case BLEND_FUNC: assert( size == 4 ); { int sf = (*++it).m_int; int df = (*++it).m_int; glBlendFunc( ToGLBlendFun( sf ), ToGLBlendFun( df )); } break; case BIND_TEXTURE: assert( size == 4 ); { int target = ToGLFlag( (*++it).m_int ); int index = (*++it).m_int; glBindTexture( target, index ); } break; case MATERIAL_PROPERTY_FLOAT_4: assert ( size == 8 ); { int face = ToGLFlag( (*++it).m_int ); int prop = ToGLMaterial( (*++it).m_int ); float color[4]; for ( int i=0; i<4; ++i ) { color[i] = (*++it).m_float; } glMaterialfv( face, prop, color ); } break; case MATERIAL_PROPERTY_FLOAT: assert( size == 5 ); { int face = ToGLFlag( (*++it).m_int ); int prop = ToGLMaterial( (*++it).m_int ); float x = (*++it).m_float; glMaterialf( face, prop, x ); } break; case LIGHT_PROPERTY_FLOAT_4: assert ( size == 8 ); { int light = ToGLFlag( (*++it).m_int ); int prop = ToGLLight( (*++it).m_int ); float color[4]; for ( int i=0; i<4; ++i ) { color[i] = (*++it).m_float; } glLightfv( light, prop, color ); } break; case LIGHT_PROPERTY_FLOAT_3: assert ( size == 7 ); { int light = ToGLFlag( (*++it).m_int ); int prop = ToGLLight( (*++it).m_int ); float direction[3]; for ( int i=0; i<3; ++i ) { direction[i] = (*++it).m_float; } glLightfv( light, prop, direction ); } break; case LIGHT_PROPERTY_FLOAT: assert( size == 5 ); { int light = ToGLFlag( (*++it).m_int ); int prop = ToGLLight( (*++it).m_int ); float x = (*++it).m_float; glLightf( light, prop, x ); } break; case LIGHT_MODEL_PROPERTY_FLOAT_4: assert( size == 7 ); { int prop = (*++it).m_int; float color[4]; for ( int i=0; i<4; ++i ) { color[i] = (*++it).m_float; } glLightModelfv( prop, color ); } break; case LIGHT_MODEL_PROPERTY_INT: assert( size == 4 ); { int prop = ToGLLightModel( (*++it).m_int ); int x = (*++it).m_int; glLightModeli( prop, x ); } break; case COLOR_MATERIAL_MODE: assert( size == 4 ); { int face = ToGLFlag( (*++it).m_int ); int mode = ToGLMaterial( (*++it).m_int ); glColorMaterial( face, mode ); } break; case BEGIN: assert( size == 3 ); { int type = (*++it).m_int; glBegin( ToGLPrimitive( type )); } break; case END: assert( size == 2 ); glEnd(); break; case VERTEX: assert( size == 5 ); { float x = (*++it).m_float; float y = (*++it).m_float; float z = (*++it).m_float; glVertex3f(x,y,z); } break; case NORMAL: assert( size == 5 ); { float x = (*++it).m_float; float y = (*++it).m_float; float z = (*++it).m_float; glNormal3f(x,y,z); } break; case COLOR: assert( size == 6 ); { float r = (*++it).m_float; float g = (*++it).m_float; float b = (*++it).m_float; float a = (*++it).m_float; glColor4f(r,g,b,a); } break; case TEXTURE_COORD: assert( size == 4 ); { float u = (*++it).m_float; float v = (*++it).m_float; glTexCoord2f(u,v); } break; // Client State case ENABLE_CLIENT_STATE: assert( size == 3 ); { int flag = (*++it).m_int; if ( flag != INDEX_ARRAY ) { glEnableClientState( ToGLClientFlag( flag )); } } break; case DISABLE_CLIENT_STATE: assert( size == 3 ); { int flag = (*++it).m_int; if ( flag != INDEX_ARRAY ) { glDisableClientState( ToGLClientFlag( flag )); } } break; case VERTEX_ARRAY: assert( size == 4 ); { void *ptr = (*++it).m_pointer; unsigned int s = (*++it).m_uint; glVertexPointer( 3, GL_FLOAT, sizeof( GAL::P3f ), ptr ); } break; case NORMAL_ARRAY: assert( size == 4 ); { void *ptr = (*++it).m_pointer; unsigned int s = (*++it).m_uint; glNormalPointer( GL_FLOAT, sizeof( GAL::P3f ), ptr ); } break; case COLOR_ARRAY: assert( size == 4 ); { void *ptr = (*++it).m_pointer; unsigned int s = (*++it).m_uint; glColorPointer( 4, GL_FLOAT, sizeof( GAL::P4f ), ptr ); } break; case TEXTURE_COORD_ARRAY: assert( size == 4 ); { void *ptr = (*++it).m_pointer; unsigned int s = (*++it).m_uint; glTexCoordPointer( 2, GL_FLOAT, sizeof( GAL::P2f ), ptr ); } break; case INDEX_ARRAY: assert( size == 4 ); { void *ptr = (*++it).m_pointer; unsigned int s = (*++it).m_uint; m_indexPointer = reinterpret_cast< unsigned int *>( ptr ); m_numIndices = s; } break; case DRAW_ELEMENTS: assert( size == 5 ); { int type = (*++it).m_int; unsigned int first = (*++it).m_int; unsigned int count = (*++it).m_int; glDrawElements( ToGLPrimitive( type ), count, GL_UNSIGNED_INT, m_indexPointer + first ); } break; case MESSAGE_CB: { int cbOffset = (*++it).m_int; char *cbPtr = reinterpret_cast< char *>( const_cast< int * >( &((*++it).m_int ))); cbPtr += cbOffset; MessageCallback *pCB = reinterpret_cast< MessageCallback * >( cbPtr ); Invoke( pCB->Apply()); std::advance( it, size-4 ); } break; default: std::advance( it, size-2 ); break; }; } }
static void init() { glPushGroupMarkerEXT(0, "init"); glGenTextures( 1, &tex ); GLubyte pix[] = { 0x60, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x80, 0x00, 0xff, 0x80, 0x80, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x80, 0x80, 0x80, 0xff, 0x00, 0x80, 0x80, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x80, 0x00, 0xff, 0x80, 0x00, 0xff, 0xff, 0x00, 0x00, 0x80, 0xff }; glTextureImage2DEXT( tex, GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix ); glTextureParameteriEXT( tex, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTextureParameteriEXT( tex, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glBindMultiTextureEXT( texunit, GL_TEXTURE_2D, tex ); GLfloat mat_specular[] = { 0.0f, 0.0f, 1.0f, 1.0f }; GLfloat mat_shininess[] = { 50.0f }; GLfloat light_position[] = { 1.0f, 1.0f, 0.2f, 1.0f }; GLfloat light_atten[] = { 1.0f, 1.0f, 1.0f }; GLfloat light_diffuse[] = { 10.0f, 10.0f, 10.0f, 10.0f }; GLfloat light_specular[] = { 10.0f, 10.0f, 10.0f, 10.0f }; GLfloat light_spotdir[] = { -0.1f, -0.1f, -1.0f }; GLfloat light_spotcut[] = { 30.0f }; GLfloat light_spotexp[] = { 3.0f }; glClearColor (0.0, 0.0, 0.0, 0.0); //glShadeModel (GL_SMOOTH); glMatrixPushEXT( GL_MODELVIEW ); glMatrixLoadIdentityEXT( GL_MODELVIEW ); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess); //glMaterialfv(GL_BACK, GL_SHININESS, mat_shininess); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, light_atten[1] ); glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, light_atten[2] ); glLightfv( GL_LIGHT0, GL_DIFFUSE, light_diffuse ); glLightfv( GL_LIGHT0, GL_SPECULAR, light_specular ); glLightfv( GL_LIGHT0, GL_SPOT_DIRECTION, light_spotdir ); glLightfv( GL_LIGHT0, GL_SPOT_CUTOFF, light_spotcut ); glLightfv( GL_LIGHT0, GL_SPOT_EXPONENT, light_spotexp ); //GLfloat light_ambient[] = { 0.0, -1.0, 0.0, 0.0 }; //glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glMatrixPopEXT( GL_MODELVIEW ); glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE ); glLightModelf( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR ); glEnable( GL_COLOR_MATERIAL ) ; glColorMaterial( GL_BACK, GL_SPECULAR ); glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE ); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glFogi( GL_FOG_MODE, GL_LINEAR ); glFogf( GL_FOG_START, 2.0f ); glFogf( GL_FOG_END, 4.0f ); GLfloat fog_color[] = { 1.0, 1.0, 0.0, 0.0 }; glFogfv( GL_FOG_COLOR, fog_color ); glEnable( GL_CLIP_PLANE3 ); GLdouble clip[] = { 1, 1, -1, 0 }; glClipPlane( GL_CLIP_PLANE3, clip ); glPopGroupMarkerEXT(); }
C_OGL_3DMODEL::C_OGL_3DMODEL( const S3DMODEL &a3DModel, MATERIAL_MODE aMaterialMode ) { m_ogl_idx_list_meshes = 0; m_ogl_idx_list_opaque = 0; m_ogl_idx_list_transparent = 0; m_nr_meshes = 0; m_meshs_bbox = NULL; // Validate a3DModel pointers wxASSERT( a3DModel.m_Materials != NULL ); wxASSERT( a3DModel.m_Meshes != NULL ); wxASSERT( a3DModel.m_MaterialsSize > 0 ); wxASSERT( a3DModel.m_MeshesSize > 0 ); if( (a3DModel.m_Materials != NULL) && (a3DModel.m_Meshes != NULL) && (a3DModel.m_MaterialsSize > 0) && (a3DModel.m_MeshesSize > 0) ) { m_nr_meshes = a3DModel.m_MeshesSize; m_meshs_bbox = new CBBOX[a3DModel.m_MeshesSize]; // Generate m_MeshesSize auxiliar lists to render the meshes m_ogl_idx_list_meshes = glGenLists( a3DModel.m_MeshesSize ); // Render each mesh of the model // ///////////////////////////////////////////////////////////////////// for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i ) { if( glIsList( m_ogl_idx_list_meshes + mesh_i ) ) { const SMESH &mesh = a3DModel.m_Meshes[mesh_i]; // Validate the mesh pointers wxASSERT( mesh.m_Positions != NULL ); wxASSERT( mesh.m_FaceIdx != NULL ); wxASSERT( mesh.m_Normals != NULL ); if( (mesh.m_Positions != NULL) && (mesh.m_Normals != NULL) && (mesh.m_FaceIdx != NULL) && (mesh.m_FaceIdxSize > 0) && (mesh.m_VertexSize > 0) ) { SFVEC4F *pColorRGBA = NULL; // Create the bbox for this mesh // ///////////////////////////////////////////////////////// m_meshs_bbox[mesh_i].Reset(); for( unsigned int vertex_i = 0; vertex_i < mesh.m_VertexSize; ++vertex_i ) { m_meshs_bbox[mesh_i].Union( mesh.m_Positions[vertex_i] ); } // Make sure we start with client state disabled // ///////////////////////////////////////////////////////// glDisableClientState( GL_TEXTURE_COORD_ARRAY ); glDisableClientState( GL_COLOR_ARRAY ); // Enable arrays client states // ///////////////////////////////////////////////////////// glEnableClientState( GL_VERTEX_ARRAY ); glEnableClientState( GL_NORMAL_ARRAY ); glVertexPointer( 3, GL_FLOAT, 0, mesh.m_Positions ); glNormalPointer( GL_FLOAT, 0, mesh.m_Normals ); if( mesh.m_Color != NULL ) { glEnableClientState( GL_COLOR_ARRAY ); float transparency = 0.0f; if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize ) transparency = a3DModel.m_Materials[mesh.m_MaterialIdx].m_Transparency; if( (transparency > FLT_EPSILON) && (aMaterialMode == MATERIAL_MODE_NORMAL) ) { // Create a new array of RGBA colors pColorRGBA = new SFVEC4F[mesh.m_VertexSize]; // Copy RGB array and add the Alpha value for( unsigned int i = 0; i < mesh.m_VertexSize; ++i ) pColorRGBA[i] = SFVEC4F( mesh.m_Color[i], 1.0f - transparency ); // Load an RGBA array glColorPointer( 4, GL_FLOAT, 0, pColorRGBA ); } else { switch( aMaterialMode ) { case MATERIAL_MODE_NORMAL: case MATERIAL_MODE_DIFFUSE_ONLY: // load the original RGB color array glColorPointer( 3, GL_FLOAT, 0, mesh.m_Color ); break; case MATERIAL_MODE_CAD_MODE: // Create a new array of RGBA colors pColorRGBA = new SFVEC4F[mesh.m_VertexSize]; // Copy RGB array and add the Alpha value for( unsigned int i = 0; i < mesh.m_VertexSize; ++i ) { pColorRGBA[i] = SFVEC4F( MaterialDiffuseToColorCAD( mesh.m_Color[i] ), 1.0f ); } // Load an RGBA array glColorPointer( 4, GL_FLOAT, 0, pColorRGBA ); break; default: break; } } } if( mesh.m_Texcoords != NULL ) { glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glTexCoordPointer( 2, GL_FLOAT, 0, mesh.m_Texcoords ); } // Compile the display list to store triangles // ///////////////////////////////////////////////////////// glNewList( m_ogl_idx_list_meshes + mesh_i, GL_COMPILE ); // Set material properties // ///////////////////////////////////////////////////////// if( mesh.m_Color != NULL ) { // This enables the use of the Color Pointer information glEnable( GL_COLOR_MATERIAL ); glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE ); } else { glDisable( GL_COLOR_MATERIAL ); } if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize ) { switch( aMaterialMode ) { case MATERIAL_MODE_NORMAL: OGL_SetMaterial( a3DModel.m_Materials[mesh.m_MaterialIdx] ); break; case MATERIAL_MODE_DIFFUSE_ONLY: OGL_SetDiffuseOnlyMaterial( a3DModel.m_Materials[mesh.m_MaterialIdx].m_Diffuse ); break; case MATERIAL_MODE_CAD_MODE: OGL_SetDiffuseOnlyMaterial( MaterialDiffuseToColorCAD( a3DModel.m_Materials[mesh.m_MaterialIdx].m_Diffuse ) ); break; default: break; } } // Draw mesh // ///////////////////////////////////////////////////////// glDrawElements( GL_TRIANGLES, mesh.m_FaceIdxSize, GL_UNSIGNED_INT, mesh.m_FaceIdx ); glDisable( GL_COLOR_MATERIAL ); glEndList(); // Disable arrays client states // ///////////////////////////////////////////////////////// glDisableClientState( GL_TEXTURE_COORD_ARRAY ); glDisableClientState( GL_COLOR_ARRAY ); glDisableClientState( GL_NORMAL_ARRAY ); glDisableClientState( GL_VERTEX_ARRAY ); glFinish(); delete [] pColorRGBA; } } }// for each mesh m_ogl_idx_list_opaque = glGenLists( 1 ); // Check if the generated list is valid if( glIsList( m_ogl_idx_list_opaque ) ) { bool have_opaque_meshes = false; bool have_transparent_meshes = false; // Compile the model display list glNewList( m_ogl_idx_list_opaque, GL_COMPILE ); // Render each mesh display list (opaque first) // ///////////////////////////////////////////////////////////////// for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i ) { const SMESH &mesh = a3DModel.m_Meshes[mesh_i]; if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize ) { const SMATERIAL &material = a3DModel.m_Materials[mesh.m_MaterialIdx]; if( material.m_Transparency == 0.0f ) { have_opaque_meshes = true; // Flag that we have at least one opaque mesh glCallList( m_ogl_idx_list_meshes + mesh_i ); } else { have_transparent_meshes = true; // Flag that we found a transparent mesh } } } glEndList(); if( !have_opaque_meshes ) { // If we dont have opaque meshes, we can free the list glDeleteLists( m_ogl_idx_list_opaque, 1 ); m_ogl_idx_list_opaque = 0; } if( have_transparent_meshes ) { m_ogl_idx_list_transparent = glGenLists( 1 ); // Check if the generated list is valid if( glIsList( m_ogl_idx_list_transparent ) ) { // Compile the model display list glNewList( m_ogl_idx_list_transparent, GL_COMPILE ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // Render each mesh display list // ///////////////////////////////////////////////////////// for( unsigned mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i ) { const SMESH &mesh = a3DModel.m_Meshes[mesh_i]; if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize ) { const SMATERIAL &material = a3DModel.m_Materials[mesh.m_MaterialIdx]; // Render the transparent mesh if it have a transparency value if( material.m_Transparency != 0.0f ) glCallList( m_ogl_idx_list_meshes + mesh_i ); } } glDisable( GL_BLEND ); glEndList(); } else { m_ogl_idx_list_transparent = 0; } } } else { m_ogl_idx_list_opaque = 0; } // Create the main bbox // ///////////////////////////////////////////////////////////////////// m_model_bbox.Reset(); for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i ) m_model_bbox.Union( m_meshs_bbox[mesh_i] ); glFinish(); } }
/* * OpenGL (GLUT) calls this routine to display the scene */ void display() { const double len=2000; // Length of axes float Position[] = {X+700*Cos(Th)-400,Y+50*Sin(Th),300+Z+1200*Sin(Th),1-inf}; // Erase the window and the depth buffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // Enable Z-buffering in OpenGL glEnable(GL_DEPTH_TEST); // Undo previous transformations glLoadIdentity(); // Perspective - set eye position if (mode) { double Ex = -2*dim*Sin(th)*Cos(ph); double Ey = +2*dim *Sin(ph); double Ez = +2*dim*Cos(th)*Cos(ph); gluLookAt(Ex,Ey,Ez , 0,0,0 , 0,Cos(ph),0); } // Orthogonal - set world orientation else { glRotatef(ph,1,0,0); glRotatef(th,0,1,0); } glShadeModel(smooth?GL_SMOOTH:GL_FLAT); // Light switch if (light) { // Translate intensity to color vectors float Ambient[] = {0.01*ambient ,0.01*ambient ,0.01*ambient ,1.0}; float Diffuse[] = {0.01*diffuse ,0.01*diffuse ,0.01*diffuse ,1.0}; float Specular[] = {0.01*specular,0.01*specular,0.01*specular,1.0}; // Spotlight color and direction float yellow[] = {1.0,1.0,0.0,1.0}; float Direction[] = {Cos(Th)*Sin(Ph),Sin(Th)*Sin(Ph),-Cos(Ph),0}; // Draw light position as ball (still no lighting here) ball(Position[0],Position[1],Position[2] , 10); // OpenGL should normalize normal vectors glEnable(GL_NORMALIZE); // Enable lighting glEnable(GL_LIGHTING); // Location of viewer for specular calculations glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,local); // Two sided mode glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,side); // glColor sets ambient and diffuse color materials glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); // Set specular colors glMaterialfv(GL_FRONT,GL_SPECULAR,yellow); glMaterialfv(GL_FRONT,GL_SHININESS,shinyvec); // Enable light 0 glEnable(GL_LIGHT0); // Set ambient, diffuse, specular components and position of light 0 glLightfv(GL_LIGHT0,GL_AMBIENT ,Ambient); glLightfv(GL_LIGHT0,GL_DIFFUSE ,Diffuse); glLightfv(GL_LIGHT0,GL_SPECULAR,Specular); glLightfv(GL_LIGHT0,GL_POSITION,Position); // Set spotlight parameters glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,Direction); glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,sco); glLightf(GL_LIGHT0,GL_SPOT_EXPONENT,Exp); // Set attenuation glLightf(GL_LIGHT0,GL_CONSTANT_ATTENUATION ,at0/100.0); glLightf(GL_LIGHT0,GL_LINEAR_ATTENUATION ,at1/100.0); glLightf(GL_LIGHT0,GL_QUADRATIC_ATTENUATION,at2/100.0); } else glDisable(GL_LIGHTING); // Enable textures if (ntex) glEnable(GL_TEXTURE_2D); else glDisable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); // drawing the 3 great pyramids of Egypt pyramid(0,0,0, 230.124,138.684,230.124, 0); pyramid(300,0,115, 30,30,30, 0); pyramid(300,0,20, 30,30,30, 0); pyramid(300,0,-75, 30,30,30, 0); pyramid(-500,0,600, 230,136,230, 0); cube(-100, 0, 600, 115, 30, 50, 0); // sphere2(-20, 90, 600, 30); pyramid(-900,0,990, 103.327,60.96,103.327, 0); // drawig the queens' pyramids pyramid(-900,0, 1200, 30, 30, 30, 0); pyramid(-1000,0, 1200, 30, 30, 30, 0); pyramid(-800,0, 1200, 30, 30, 30, 0); glDisable(GL_TEXTURE_2D); // Draw axes - no lighting from here on glDisable(GL_LIGHTING); glColor3f(1,1,1); if (axes) { glBegin(GL_LINES); glVertex3d(0.0,0.0,0.0); glVertex3d(len,0.0,0.0); glVertex3d(0.0,0.0,0.0); glVertex3d(0.0,len,0.0); glVertex3d(0.0,0.0,0.0); glVertex3d(0.0,0.0,len); glEnd(); // Label axes glRasterPos3d(len,0.0,0.0); Print("X"); glRasterPos3d(0.0,len,0.0); Print("Y"); glRasterPos3d(0.0,0.0,len); Print("Z"); } // Display parameters glWindowPos2i(5,5); Print("Angle=%d,%d Dim=%.1f Projection=%s Light=%s", th,ph,dim,mode?"Orthogonal":"Perpective",light?"On":"Off"); if (light) { glWindowPos2i(5,65); Print("Cutoff=%.0f Exponent=%.1f Direction=%d,%d Attenuation=%.2f,%.2f,%.2f",sco,Exp,Th,Ph,at0/100.0,at1/100.0,at2/100.0); glWindowPos2i(5,45); Print("Model=%s LocalViewer=%s TwoSided=%s Position=%.1f,%.1f,%.1f,%.1f",smooth?"Smooth":"Flat",local?"On":"Off",side?"On":"Off",Position[0],Position[1],Position[2],Position[3]); glWindowPos2i(5,25); Print("Ambient=%d Diffuse=%d Specular=%d Emission=%d Shininess=%.0f",ambient,diffuse,specular,emission,shinyvec[0]); } // Render the scene and make it visible ErrCheck("display"); glFlush(); glutSwapBuffers(); }
int main(int argc, char* argv[]) { atexit(onExit); /****************************************/ /* Initialize GLUT and create window */ /****************************************/ glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowPosition(50, 50); glutInitWindowSize(500, 500); main_window = glutCreateWindow("COMP 175 In Class Assignment 10"); glutDisplayFunc(myGlutDisplay); glutReshapeFunc(myGlutReshape); /****************************************/ /* Set up OpenGL lighting */ /****************************************/ glShadeModel(GL_SMOOTH); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); static float one[] = { 1, 1, 1, 1 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, one); /****************************************/ /* Set up OpenGL Shaders */ /****************************************/ // Initialize our shader using our special shader manager class. myShaderManager = new shaderManager(); myShaderManager->loadImage("brick.ppm",0); myShaderManager->loadImage("bump.ppm",1); //myShaderManager->initShader("shaders/Bump/bump.vert","shaders/Bump/bump.frag"); dragonPLY = new ply("./data/dragon.ply"); /****************************************/ /* Enable z-buferring */ /****************************************/ glEnable(GL_DEPTH_TEST); glPolygonOffset(1, 1); /****************************************/ /* Here's the GLUI code */ /****************************************/ GLUI *glui = GLUI_Master.create_glui("GLUI"); /*** Create the bottom subwindow ***/ glui2 = GLUI_Master.create_glui_subwindow( main_window, GLUI_SUBWINDOW_BOTTOM ); // Create a rotation widget GLUI_Rotation *view_rot = new GLUI_Rotation(glui2, "Objects", view_rotate ); view_rot->set_spin( 1.0 ); // Navigate our world new GLUI_Column( glui2, false ); GLUI_Translation *trans_x = new GLUI_Translation(glui2, "Objects X", GLUI_TRANSLATION_X, obj_pos ); trans_x->set_speed( .1 ); new GLUI_Column( glui2, false ); GLUI_Translation *trans_y = new GLUI_Translation( glui2, "Objects Y", GLUI_TRANSLATION_Y, &obj_pos[1] ); trans_y->set_speed( .1 ); new GLUI_Column( glui2, false ); GLUI_Translation *trans_z = new GLUI_Translation( glui2, "Objects Z", GLUI_TRANSLATION_Z, &obj_pos[2] ); trans_z->set_speed( .1 ); glui2->add_column(true); GLUI_Panel *render_panel = glui2->add_panel("Render"); new GLUI_Checkbox(render_panel, "Wireframe", &wireframe); new GLUI_Checkbox(render_panel, "Filled", &filled); new GLUI_Checkbox(render_panel, "Grid", &grid); glui2->add_button("Quit", 0, (GLUI_Update_CB)exit); glui->set_main_gfx_window(main_window); /* We register the idle callback with GLUI, *not* with GLUT */ GLUI_Master.set_glutIdleFunc(myGlutIdle); glutMainLoop(); return EXIT_SUCCESS; }
void Renderer::setLighting(){ // recompute emissive light colors for highlighted bodies Real now=TimingInfo::getNow(/*even if timing is disabled*/true)*1e-9; highlightEmission0[0]=highlightEmission0[1]=highlightEmission0[2]=.8*normSquare(now,1); highlightEmission1[0]=highlightEmission1[1]=highlightEmission0[2]=.5*normSaw(now,2); glClearColor(bgColor[0],bgColor[1],bgColor[2],1.0); // set light sources glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,1); // important: do lighting calculations on both sides of polygons const GLfloat pos[4] = {(GLfloat)lightPos[0],(GLfloat)lightPos[1],(GLfloat)lightPos[2],(GLfloat)1.0}; const GLfloat ambientColor[4]={0.5,0.5,0.5,1.0}; const GLfloat specularColor[4]={1,1,1,1.}; const GLfloat diffuseLight[4] = { (GLfloat)lightColor[0], (GLfloat)lightColor[1], (GLfloat)lightColor[2], 1.0f }; glLightfv(GL_LIGHT0, GL_POSITION,pos); glLightfv(GL_LIGHT0, GL_SPECULAR, specularColor); glLightfv(GL_LIGHT0, GL_AMBIENT, ambientColor); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight); if (light1) glEnable(GL_LIGHT0); else glDisable(GL_LIGHT0); const GLfloat pos2[4] = {(GLfloat)light2Pos[0],(GLfloat)light2Pos[1],(GLfloat)light2Pos[2],1.0}; const GLfloat ambientColor2[4]={0.0,0.0,0.0,1.0}; const GLfloat specularColor2[4]={.8,.8,.8,1.}; const GLfloat diffuseLight2[4] = { (GLfloat)light2Color[0], (GLfloat)light2Color[1], (GLfloat)light2Color[2], 1.0f }; glLightfv(GL_LIGHT1, GL_POSITION,pos2); glLightfv(GL_LIGHT1, GL_SPECULAR, specularColor2); glLightfv(GL_LIGHT1, GL_AMBIENT, ambientColor2); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLight2); if (light2) glEnable(GL_LIGHT1); else glDisable(GL_LIGHT1); glEnable(GL_LIGHTING); // show both sides of triangles glDisable(GL_CULL_FACE); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,1); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,1); // http://www.sjbaker.org/steve/omniv/opengl_lighting.html glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); //Shared material settings resetSpecularEmission(); // not sctrictly lighting related glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); //glEnable(GL_POLYGON_SMOOTH); glShadeModel(GL_SMOOTH); #ifdef __MINGW64__ // see http://www.opengl.org/discussion_boards/showthread.php/133406-GL_RESCALE_NORMAL-in-VC // why is glext.h not in mingw: // * http://sourceforge.net/projects/mingw-w64/forums/forum/723797/topic/3572810 glEnable(GL_NORMALIZE); #else glEnable(GL_RESCALE_NORMAL); #endif // important for rendering text, to avoid repetivie glDisable(GL_TEXTURE_2D) ... glEnable(GL_TEXTURE_2D) // glBindTexture(GL_TEXTURE_2D,0); };
ENTRYPOINT void init_flipflop(ModeInfo *mi) { int screen; Flipflopcreen *c; if (MI_IS_WIREFRAME(mi)) textured = 0; /* Set all constants to their correct values */ if (board_avg_size != 0) { /* general size specified by user */ board_x_size = board_avg_size; board_y_size = board_avg_size; } else { board_avg_size = (board_x_size + board_y_size) / 2; } if ((numsquares == 0) && (freesquares != 0)) { numsquares = board_x_size * board_y_size - freesquares; } if (strcmp(flipflopmode_str, "tiles")) { textured = 0; /* textures look dumb in stick mode */ half_thick = 1.0 * DEF_STICK_THICK / 100.0; if (numsquares == 0) { /* No value defined by user */ numsquares = board_x_size * board_y_size * DEF_STICK_RATIO / 100; } } else { half_thick = 1.0 * DEF_TILE_THICK / 100.0; if (numsquares == 0) { /* No value defined by user */ numsquares = board_x_size * board_y_size * DEF_TILE_RATIO/ 100;; } } if (board_avg_size < 2) { fprintf (stderr,"%s: the board must be at least 2x2.\n", progname); exit(1); } if ((board_x_size < 1) || (board_y_size < 1) || (numsquares < 1)) { fprintf (stderr,"%s: the number of elements ('-count') and the dimensions of the board ('-size-x', '-size-y') must be positive integers.\n", progname); exit(1); } if (board_x_size * board_y_size <= numsquares) { fprintf (stderr,"%s: the number of elements ('-count') that you specified is too big \n for the dimensions of the board ('-size-x', '-size-y'). Nothing will move.\n", progname); } screen = MI_SCREEN(mi); wire = MI_IS_WIREFRAME(mi); if(!qs && !(qs = (Flipflopcreen *) calloc(MI_NUM_SCREENS(mi), sizeof(Flipflopcreen)))) return; c = &qs[screen]; c->window = MI_WINDOW(mi); c->trackball = gltrackball_init (False); c->flipspeed = 0.03; c->reldist = 1; c->energy = 40; if((c->glx_context = init_GL(mi))) reshape_flipflop(mi, MI_WIDTH(mi), MI_HEIGHT(mi)); else MI_CLEARWINDOW(mi); /* At this point, all the constants have already been set, */ /* so we can create the board */ c->sheet = (randsheet*) malloc(sizeof(randsheet)); randsheet_create( c->sheet ); clearbits = GL_COLOR_BUFFER_BIT; glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); setup_lights(); glEnable(GL_DEPTH_TEST); clearbits |= GL_DEPTH_BUFFER_BIT; glEnable(GL_CULL_FACE); glCullFace(GL_BACK); randsheet_initialize( c->sheet ); if( textured ){ /* check for anisotropic filtering */ if(strstr((char *)glGetString(GL_EXTENSIONS), "GL_EXT_texture_filter_anisotropic")) glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &c->anisotropic); else c->anisotropic = 0; /* allocate a new texture and get it */ glGenTextures(1, &c->texid); get_texture(mi); } }
void obj_draw( Obj *obj, Vec3D position, Vec3D rotation, Vec3D scale, Vec4D color, Sprite *texture ) { int i; ObjTriangle* triangle; float trans[4]; if (obj == NULL) { slog("cannot draw obj, none specified!"); return; } glPushMatrix(); glEnable(GL_LIGHTING); glEnable(GL_BLEND); glEnable(GL_NORMALIZE); glColorMaterial(GL_FRONT,GL_DIFFUSE); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); if(texture != NULL) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,texture->texture); } glEnable(GL_COLOR_MATERIAL); glMaterialfv(GL_FRONT,GL_DIFFUSE,trans); glDepthFunc(GL_LEQUAL); glTranslatef(position.x,position.y,position.z); glRotatef(rotation.x, 1.0f, 0.0f, 0.0f); glRotatef(rotation.y, 0.0f, 1.0f, 0.0f); glRotatef(rotation.z, 0.0f, 0.0f, 1.0f); glScalef(scale.x,scale.y,scale.z); glColor3f(color.x,color.y,color.z); glBegin(GL_TRIANGLES); for (i = 0; i < obj->num_tris; i++) { triangle = &obj->triangle_array[i]; if (obj->normal_array) { glNormal3f( obj->normal_array[triangle->p[0].n * 3], obj->normal_array[triangle->p[0].n * 3 + 1], obj->normal_array[triangle->p[0].n * 3 + 2] ); } if (obj->texel_array) { glTexCoord2f( obj->texel_array[triangle->p[0].t * 2], obj->texel_array[triangle->p[0].t * 2 + 1] ); } glVertex3f( obj->vertex_array[triangle->p[0].v * 3], obj->vertex_array[triangle->p[0].v * 3 + 1], obj->vertex_array[triangle->p[0].v * 3 + 2] ); if (obj->normal_array) { glNormal3f( obj->normal_array[triangle->p[1].n * 3], obj->normal_array[triangle->p[1].n * 3 + 1], obj->normal_array[triangle->p[1].n * 3 + 2] ); } if (obj->texel_array) { glTexCoord2f( obj->texel_array[triangle->p[1].t * 2], obj->texel_array[triangle->p[1].t * 2 + 1] ); } glVertex3f( obj->vertex_array[triangle->p[1].v * 3], obj->vertex_array[triangle->p[1].v * 3 + 1], obj->vertex_array[triangle->p[1].v * 3 + 2]); if (obj->normal_array) { glNormal3f( obj->normal_array[triangle->p[2].n * 3], obj->normal_array[triangle->p[2].n * 3 + 1], obj->normal_array[triangle->p[2].n * 3 + 2] ); } if (obj->texel_array) { glTexCoord2f( obj->texel_array[triangle->p[2].t * 2], obj->texel_array[triangle->p[2].t * 2 + 1] ); } glVertex3f( obj->vertex_array[triangle->p[2].v * 3], obj->vertex_array[triangle->p[2].v * 3 + 1], obj->vertex_array[triangle->p[2].v * 3 + 2]); } glEnd(); glColor4f(1,1,1,1); glDisable(GL_LIGHTING); glDisable(GL_BLEND); glDisable(GL_COLOR_MATERIAL); if(texture != NULL) { glDisable(GL_TEXTURE_2D); } glPopMatrix(); }
void GLWidget::initializeGL() { qglClearColor(Qt::black); glEnable(GL_DEPTH_TEST); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glShadeModel(GL_SMOOTH); glEnable(GL_NORMALIZE); glEnable(GL_LIGHTING); glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glEnable(GL_CULL_FACE); if (GLEW_OK != glewInit()) { qDebug() << "glewInit() failed!"; exit(1); } if(m_displaying_particles) { glEnable(GL_FOG); float fog_color[] = {1.0, 1.0, 1.0, 1.0}; float fog_density[] = {0.3}; glFogfv(GL_FOG_COLOR, fog_color); glFogfv(GL_FOG_DENSITY, fog_density); } float ambient[] = {0.1, 0.1, 0.1, 1.0}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glEnable(GL_LIGHT0); glLighti(GL_LIGHT0, GL_NONE, 1); skybox = new Skybox(); for (int i = 1; i<10; i++){ glNewList(i, GL_COMPILE); tree(); glEndList(); } glNewList(11, GL_COMPILE); glColor3f(1.0,1.0,1.0); sphere(); glEndList(); m_map = new Map(); change_current_chunk(); qDebug() << "HARP DARP" << m_nchunk; Heightmap * hm = m_nchunk->heightmap; m_particles = new ParticleEngine(); //cam = new TerrainCamera(2.5,2.5,hm, m_map); cam = new Camera3d(0,1.0,0, m_map); m_bloomShader = new BloomShader(this); m_toonShader = new ToonShader(); m_plainShader = new PlainShader(); m_fbo = new QGLFramebufferObject(width(), height(), QGLFramebufferObject::NoAttachment); glGenRenderbuffers(1, &m_depthBuf); }
int main(int argc, char **argv) { buildTerrain(); //Make the mian plane the lead friendly plane friendlyPlanes.push_back(mainPlane); cDetector.carriers = &carriers; cDetector.tiles = &tiles; cDetector.friendlyPlanes = &friendlyPlanes; cDetector.enemyPlanes = &enemyPlanes; cDetector.mainPlane = &mainPlane; cDetector.explosives = &explosives; //buildEnemyPlanes(); buildCarrierGroup(); buildSilos(); mainPlane.y = 45; mainPlane.explosives = &explosives; //explosives.generateExplosion(0, 45, -100, 0, 0, 0); glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100,100); glutInitWindowSize(1024,768); //glutInitWindowSize(600,400); glutCreateWindow("Flight Simulator Basic"); initScene(); // Enable lighting glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); GLfloat light_ambient[] = { 1, 1, 1, 1 }; GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_pos[] = { 0.0, 30.0, 0.0, 1 }; GLfloat light_dir[] = { 0.0, 0, 0}; GLfloat mat_specular[] = {0.3, 0.3, 0.3, 1.0}; GLfloat mat_shininess[] = { 10.0 }; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_POSITION, light_pos); glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light_dir); glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glClearColor(0.0f, 0.0f, .6f, .5f); glutIgnoreKeyRepeat(.05); glutSpecialFunc(pressKey); //glutKeyboardFunc(pressKey); glutSpecialUpFunc(releaseKey); glutDisplayFunc(renderScene); glutIdleFunc(renderScene); glutReshapeFunc(changeSize); glutMainLoop(); return(0); }