void LightingScene::init() { mode=1; // Enables lighting computations glEnable(GL_LIGHTING); // Sets up some lighting parameters // Computes lighting only using the front face normals and materials glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); // Define ambient light (do not confuse with ambient component of individual lights) glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbientLight); // Declares and enables two lights, with null ambient component light0 = new CGFlight(GL_LIGHT0, light0_pos); light0->setAmbient(ambientNull); //light0->setSpecular(yellow); lightsState.clear(); lights.clear(); lights.push_back(light0); lightsState.push_back(1); light0->disable(); light0->enable(); light1 = new CGFlight(GL_LIGHT1, light1_pos); light1->setAmbient(ambientNull); lights.push_back(light1); lightsState.push_back(1); light1->disable(); light1->enable(); light2 = new CGFlight(GL_LIGHT2, light2_pos); light2->setAmbient(ambientNull); light2->setKc(0); light2->setKl(1); light2->setKq(0); lights.push_back(light2); lightsState.push_back(1); light2->disable(); light2->enable(); light3 = new CGFlight(GL_LIGHT3, light3_pos); light3->setAmbient(ambientNull); //light3->setSpecular(yellow); light3->setKc(0); light3->setKl(0); light3->setKq(1); lights.push_back(light3); lightsState.push_back(1); light3->disable(); light3->enable(); // Uncomment below to enable normalization of lighting normal vectors glEnable (GL_NORMALIZE); //Declares scene elements table = new myTable(); wall = new Plane(); boardA = new Plane(BOARD_A_DIVISIONS); boardB = new Plane(BOARD_B_DIVISIONS); cilindro = new myCylinder(10, 5, false); cilindro2 = new myCylinder(10, 5, true); semiEsfera = new mySphere(100, 10); relogio=new myClock(); robot = new myRobot(); robot->setRotation(200); robot->setX(7); robot->setY(0); robot->setZ(7); //Declares materials materialA = new CGFappearance(ambA,difA,specA,shininessA); materialB = new CGFappearance(ambB,difB,specB,shininessB); materialC = new CGFappearance(ambC,difC,specC,shininessC); materialD = new CGFappearance(ambD,difD,specD,shininessD); tableAppearance = new CGFappearance(ambTable, difTable, specTable, shininessTable); tableAppearance->setTexture("../textures/table.png"); boardAppearance = new CGFappearance(ambBoard, difBoard, specBoard, shininessBoard); boardAppearance->setTexture("../textures/board.png"); slidesAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides); slidesAppearance->setTexture("../textures/slides.png"); windowAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides); windowAppearance->setTexture("../textures/window.png"); landscapeAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides); landscapeAppearance->setTexture("../textures/landscape.jpg"); floorAppearance = new CGFappearance(ambTable, difTable, specTable, shininessTable); floorAppearance->setTexture("../textures/floor.png"); relogioAppearance = new CGFappearance(ambBoard, difBoard, specBoard, shininessBoard); relogioAppearance->setTexture("../textures/clock.png"); robotAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides); robotAppearance->setTexture("../textures/robot1.jpg"); // Flat Shading //glShadeModel(GL_FLAT); //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); setUpdatePeriod(100); sceneVar = 0; }
void Scene::init() { //background glClearColor(0,0,0,0); //shading glShadeModel(GL_SMOOTH); //cullface glEnable(GL_CULL_FACE); glCullFace(GL_BACK); //cullorder glFrontFace(GL_CCW); // Enables lighting computations glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); // Sets up some lighting parameters glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); float ambient[4] = {1,1,1,1}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); setUpdatePeriod(30); root = new Node(); textures["menuTex"] = new CGFtexture("../../YASF/imgs/menu.jpg"); float colorA[4] = {1,1,1,1}; float ambientA[4] = {1,1,1,1}; float diffuseA[4] = {1,1,1,1}; float specularA[4] = {1,1,1,1}; appearances["menu"] = new Appearance(colorA, ambientA, diffuseA, specularA, 1, textures["menuTex"], 1, 1); appearances["menu_default"] = new Appearance(colorA, ambientA, diffuseA, specularA, 0); Node* menuRoot = new Node(); root->addChildNode(menuRoot); //Menu Node* menuBase = new Node(); float xy1[2] = {0,0}; float xy2[2] = {5,4}; Rect* menu = new Rect(xy1, xy2); menuBase->addChildPrimitive(menu); menuBase->setAppearance(appearances["menu"]); menuRoot->addChildNode(menuBase); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslated(-9002.5,0,0); GLfloat transformationMatrix[16]; glGetFloatv(GL_MODELVIEW_MATRIX, transformationMatrix); menuRoot->setTransformations(transformationMatrix); glPopMatrix(); //Minus Node* minus = new Node(); float xy3[2] = {0.35, 0.2}; float xy4[2] = {0.85, 0.7}; Rect* minusRect = new Rect(xy3, xy4); minus->addChildPrimitive(minusRect); minus->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(minus); //Plus Node* plus = new Node(); float xy5[2] = {0.85, 0.2}; float xy6[2] = {1.35, 0.7}; Rect* plusRect = new Rect(xy5, xy6); plus->addChildPrimitive(plusRect); plus->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(plus); //Replay Node* replay = new Node(); float xy19[2] = {2.95, 0.2}; float xy20[2] = {3.95, 0.7}; Rect* replayRect = new Rect(xy19, xy20); replay->addChildPrimitive(replayRect); replay->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(replay); //PVP Node* pvp = new Node(); float xy7[2] = {1.8, 2.1}; float xy8[2] = {5, 2.8}; Rect* pvpRect = new Rect(xy7, xy8); pvp->addChildPrimitive(pvpRect); pvp->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(pvp); //PVC Node* pvc = new Node(); float xy9[2] = {1.8, 1.4}; float xy10[2] = {5, 2.1}; Rect* pvcRect = new Rect(xy9, xy10); pvc->addChildPrimitive(pvcRect); pvc->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(pvc); //CVC Node* cvc = new Node(); float xy11[2] = {1.8, 0.7}; float xy12[2] = {5, 1.4}; Rect* cvcRect = new Rect(xy11, xy12); cvc->addChildPrimitive(cvcRect); cvc->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(cvc); //SET1 Node* set1 = new Node(); float xy13[2] = {0.15, 1.2}; float xy14[2] = {0.65, 1.7}; Rect* set1Rect = new Rect(xy13, xy14); set1->addChildPrimitive(set1Rect); set1->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(set1); //SET2 Node* set2 = new Node(); float xy15[2] = {0.65, 1.2}; float xy16[2] = {1.1, 1.7}; Rect* set2Rect = new Rect(xy15, xy16); set2->addChildPrimitive(set2Rect); set2->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(set2); //SET3 Node* set3 = new Node(); float xy17[2] = {1.1, 1.2}; float xy18[2] = {1.6, 1.7}; Rect* set3Rect = new Rect(xy17, xy18); set3->addChildPrimitive(set3Rect); set3->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(set3); //EASY Node* easy = new Node(); float xy21[2] = {2.0, 2.95}; float xy22[2] = {2.8, 3.35}; Rect* easyRect = new Rect(xy21, xy22); easy->addChildPrimitive(easyRect); easy->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(easy); //MEDIUM Node* medium = new Node(); float xy23[2] = {2.9, 2.95}; float xy24[2] = {3.9, 3.35}; Rect* mediumRect = new Rect(xy23, xy24); medium->addChildPrimitive(mediumRect); medium->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(medium); //hard Node* hard = new Node(); float xy25[2] = {4.0, 2.95}; float xy26[2] = {4.8, 3.35}; Rect* hardRect = new Rect(xy25, xy26); hard->addChildPrimitive(hardRect); hard->setAppearance(appearances["menu_default"]); menuRoot->addChildNode(hard); // Transparent set1->setTransparent(true); set2->setTransparent(true); set3->setTransparent(true); minus->setTransparent(true); plus->setTransparent(true); pvp->setTransparent(true); pvc->setTransparent(true); cvc->setTransparent(true); replay->setTransparent(true); easy->setTransparent(true); medium->setTransparent(true); hard->setTransparent(true); // Picking int* picking = new int(2); picking[0] = -1; picking[1] = 1; set1->setPickingNames(vector<int>(picking, picking + 2)); picking[1] = 2; set2->setPickingNames(vector<int>(picking, picking + 2)); picking[1] = 3; set3->setPickingNames(vector<int>(picking, picking + 2)); picking[0] = -2; picking[1] = -1; minus->setPickingNames(vector<int>(picking, picking + 2)); picking[1] = 1; plus->setPickingNames(vector<int>(picking, picking + 2)); picking[0] = -3; picking[1] = 1; pvp->setPickingNames(vector<int>(picking, picking + 2)); picking[1] = 2; pvc->setPickingNames(vector<int>(picking, picking + 2)); picking[1] = 3; cvc->setPickingNames(vector<int>(picking, picking + 2)); picking[1] = 4; replay->setPickingNames(vector<int>(picking, picking + 2)); picking[0] = -4; picking[1] = 1; easy->setPickingNames(vector<int>(picking, picking + 2)); picking[0] = -4; picking[1] = 2; medium->setPickingNames(vector<int>(picking, picking + 2)); picking[0] = -4; picking[1] = 3; hard->setPickingNames(vector<int>(picking, picking + 2)); //Cameras float pos1[3] = {-9000,2,2.5}; float pos2[3] = {-9000,2,0}; CGFscene::activeCamera = new CameraPerspective(1.0, 100.0, 90.0, pos1, pos2); //Lights float pos[3] = {5,2,5}; float specular0[4] = {0,0,0,0}; lightings["menu_omni"] = new LightOmni(GL_LIGHT0, "true", pos, ambientA, diffuseA, specular0); }
void RAS_OpenGLRasterizer::SetAmbient(float factor) { float ambient[] = {m_ambr * factor, m_ambg * factor, m_ambb * factor, 1.0f}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); }
void Init(void) { int i; float top_y = 1.0; float bottom_y = 0.0; float top_z = 0.15; float bottom_z = 0.69; float spacing = 2.5; static float lmodel_ambient[] = {0.0, 0.0, 0.0, 0.0}; static float lmodel_twoside[] = {GL_FALSE}; static float lmodel_local[] = {GL_FALSE}; static float light0_ambient[] = {0.1, 0.1, 0.1, 1.0}; static float light0_diffuse[] = {1.0, 1.0, 1.0, 0.0}; static float light0_position[] = {0.8660254, 0.5, 1, 0}; static float light0_specular[] = {1.0, 1.0, 1.0, 0.0}; static float bevel_mat_ambient[] = {0.0, 0.0, 0.0, 1.0}; static float bevel_mat_shininess[] = {40.0}; static float bevel_mat_specular[] = {1.0, 1.0, 1.0, 0.0}; static float bevel_mat_diffuse[] = {1.0, 0.0, 0.0, 0.0}; srand48(0x102342); ReInit(); for (i = 0; i < RINGS; i++) { rgb_colors[i][0] = rgb_colors[i][1] = rgb_colors[i][2] = 0; } rgb_colors[BLUERING][2] = 255; rgb_colors[REDRING][0] = 255; rgb_colors[GREENRING][1] = 255; rgb_colors[YELLOWRING][0] = 255; rgb_colors[YELLOWRING][1] = 255; mapped_colors[BLUERING] = BLUE; mapped_colors[REDRING] = RED; mapped_colors[GREENRING] = GREEN; mapped_colors[YELLOWRING] = YELLOW; mapped_colors[BLACKRING] = BLACK; dests[BLUERING][0] = -spacing; dests[BLUERING][1] = top_y; dests[BLUERING][2] = top_z; dests[BLACKRING][0] = 0.0; dests[BLACKRING][1] = top_y; dests[BLACKRING][2] = top_z; dests[REDRING][0] = spacing; dests[REDRING][1] = top_y; dests[REDRING][2] = top_z; dests[YELLOWRING][0] = -spacing / 2.0; dests[YELLOWRING][1] = bottom_y; dests[YELLOWRING][2] = bottom_z; dests[GREENRING][0] = spacing / 2.0; dests[GREENRING][1] = bottom_y; dests[GREENRING][2] = bottom_z; theTorus = glGenLists(1); glNewList(theTorus, GL_COMPILE); FillTorus(0.1, 8, 1.0, 25); glEndList(); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glClearDepth(1.0); if (rgb) { glClearColor(0.5, 0.5, 0.5, 0.0); glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular); glLightfv(GL_LIGHT0, GL_POSITION, light0_position); glEnable(GL_LIGHT0); glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_local); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glEnable(GL_LIGHTING); glMaterialfv(GL_FRONT, GL_AMBIENT, bevel_mat_ambient); glMaterialfv(GL_FRONT, GL_SHININESS, bevel_mat_shininess); glMaterialfv(GL_FRONT, GL_SPECULAR, bevel_mat_specular); glMaterialfv(GL_FRONT, GL_DIFFUSE, bevel_mat_diffuse); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glShadeModel(GL_SMOOTH); } else { glClearIndex(BACKGROUND); glShadeModel(GL_FLAT); } glMatrixMode(GL_PROJECTION); gluPerspective(45, 1.33, 0.1, 100.0); glMatrixMode(GL_MODELVIEW); }
GLvoid CLightModel::SetGlobalAmbient( GLfloat* ambient ) { glLightModelfv( GL_LIGHT_MODEL_AMBIENT, ambient ); }
void Tracks::draw(GLuint tex) { glPushMatrix(); glEnable(GL_LIGHTING); //Enable lighting glEnable(GL_LIGHT0); //Enable light #0 //Add ambient light GLfloat ambientColor[] = {0.75f, 0.75f, 0.75f, 0.5f}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor); //Add positioned light GLfloat lightColor0[] = {1.0f, 1.0f, 1.0f, 1.0f}; GLfloat lightPos0[] = {0.0f, 3.0f, 0.0f, 1.0f}; GLfloat spot_direction[] = { 0.0, -1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0); glLightfv(GL_LIGHT0, GL_POSITION, lightPos0); glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 30.0); glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ////Add ambient light //GLfloat ambientColor[] = {1.0f, 1.0f, 1.0f, 0.5f}; ////glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor); // ////Add directed light //GLfloat lightColor1[] = {0.85f, 0.85f, 0.85f, 1.0f}; //GLfloat lightPos1[] = {0.0f, 2.0f, -3.0f, 0.0f}; //glLightfv(GL_LIGHT1, GL_SPECULAR, lightColor1); //glLightfv(GL_LIGHT1, GL_POSITION, lightPos1); glBegin(GL_QUADS); //Begin quadrilateral coordinates //top //glColor3f(1.0f, 0.0f, 0.0f); glNormal3f(0.0, 1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.45f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.15f, 0.45f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.15f, 0.45f); //bottom //glColor3f(1.0f, 0.0f, 0.0f); glNormal3f(0.0, -1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); //back //glColor3f(1.0f, 0.5f, 0.0f); glNormal3f(0.0, 0.0f, -1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.45f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); //front //glColor3f(1.0f, 0.0f, 0.5f); glNormal3f(0.0, 0.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, 0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, 0.45f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); //right 1 //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.25f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, 0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); //right 2 //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.25f, 0.15f, 0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); //right 3 //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); //left 1 //glColor3f(0.5f, 0.5f, 1.0f); glNormal3f(-1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.25f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.45f, 0.15f, 0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); //left 2 //glColor3f(0.5f, 0.5f, 1.0f); glNormal3f(-1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, 0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); //left 3 //glColor3f(0.5f, 0.5f, 1.0f); glNormal3f(-1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glEnd(); //End quadrilateral coordinates glTranslatef(0.7, 0.0, 0.0); glBegin(GL_QUADS); //Begin quadrilateral coordinates //top //glColor3f(1.0f, 0.0f, 0.0f); glNormal3f(0.0, 1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.45f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.15f, 0.45f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.15f, 0.45f); //bottom //glColor3f(1.0f, 0.0f, 0.0f); glNormal3f(0.0, -1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); //back //glColor3f(1.0f, 0.5f, 0.0f); glNormal3f(0.0, 0.0f, -1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.45f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); //front //glColor3f(1.0f, 0.0f, 0.5f); glNormal3f(0.0, 0.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, 0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, 0.45f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); //right 1 //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.25f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, 0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); //right 2 //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.25f, 0.15f, 0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.25f, 0.0f, 0.25f); //right 3 //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.25f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.25f, 0.0f, -0.25f); //left 1 //glColor3f(0.5f, 0.5f, 1.0f); glNormal3f(-1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.25f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.45f, 0.15f, 0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); //left 2 //glColor3f(0.5f, 0.5f, 1.0f); glNormal3f(-1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, 0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, 0.25f); //left 3 //glColor3f(0.5f, 0.5f, 1.0f); glNormal3f(-1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.45f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-0.45f, 0.15f, -0.25f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.45f, 0.0f, -0.25f); glEnd(); //End quadrilateral coordinates glTranslatef(-0.7, 0.0, 0.0); glBegin(GL_QUADS); //bottom //glColor3f(0.5f, 0.0f, 0.0f); glNormal3f(0.0, -1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.35f, 0.15f, -0.35f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.35f, 0.15f, -0.35f); glTexCoord2f(1.0f, 1.0f); glVertex3f(0.35f, 0.15f, 0.35f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.35f, 0.15f, 0.35f); //top //glColor3f(1.0f, 0.0f, 1.0f); glNormal3f(0.0, 1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.35f, 1.0f, -0.35f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.35f, 1.0f, -0.35f); glTexCoord2f(1.0f, 1.0f); glVertex3f(0.35f, 1.0f, 0.35f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.35f, 1.0f, 0.35f); //back //glColor3f(1.0f, 0.5f, 0.0f); glNormal3f(0.0, 0.0f, -1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.35f, 0.15f, -0.35f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.35f, 0.15f, -0.35f); glTexCoord2f(1.0f, 1.0f); glVertex3f(0.35f, 1.0f, -0.35f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.35f, 1.0f, -0.35f); //front //glColor3f(1.0f, 0.0f, 0.5f); glNormal3f(0.0, 0.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.35f, 0.15f, 0.35f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.35f, 0.15f, 0.35f); glTexCoord2f(1.0f, 1.0f); glVertex3f(0.35f, 1.0f, 0.35f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.35f, 1.0f, 0.35f); //right //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(1.0, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(0.35f, 1.0f, -0.35f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.35f, 1.0f, 0.35f); glTexCoord2f(1.0f, 1.0f); glVertex3f(0.35f, 0.15f, 0.35f); glTexCoord2f(0.0f, 1.0f); glVertex3f(0.35f, 0.15f, -0.35f); //left //glColor3f(1.0f, 0.5f, 0.5f); glNormal3f(-1.0, 0.0f, 0.0f); glVertex3f(-0.35f, 1.0f, -0.35f); glVertex3f(-0.35f, 1.0f, 0.35f); glVertex3f(-0.35f, 0.15f, 0.35f); glVertex3f(-0.35f, 0.15f, -0.35f); glEnd(); glDisable(GL_TEXTURE_2D); //4 glPushMatrix(); glBegin(GL_QUADS); glColor3d(1,1,1); glVertex3f(-0.1f, 1.01f, 0.1f); glVertex3f(-0.1f, 1.01f, 0.2f); glVertex3f(0.1f, 1.01f, 0.2f); glVertex3f(0.1f, 1.01f, 0.1f); //glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-0.0f, 1.01f, -0.15f); glVertex3f(-0.0f, 1.01f, 0.3f); glVertex3f(0.1f, 1.01f, 0.3f); glVertex3f(0.1f, 1.01f, -0.15f); //glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-0.25f, 1.01f, -0.15f); glVertex3f(-0.25f, 1.01f, 0.2f); glVertex3f(-0.1f, 1.01f, 0.2f); glVertex3f(-0.1f, 1.01f, -0.15f); glEnd(); glPopMatrix(); glDisable(GL_LIGHTING); glPopMatrix(); }
void LightingScene::init() { sceneVar=0; light0On = 1; light1On = 1; light2On = 0; light3On = 0; clockAnimation = true; // Enables lighting computations glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); // Sets up some lighting parameters // Computes lighting only using the front face normals and materials glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); // Define ambient light (do not confuse with ambient component of individual lights) glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbientLight); // Declares and enables two lights, with null ambient component glShadeModel(GL_SMOOTH); light0 = new CGFlight(GL_LIGHT0, light0_pos); light0->setAmbient(ambientNull); light0->setSpecular(yellow); if (light0On == 0) light0->disable(); else light0->enable(); light1 = new CGFlight(GL_LIGHT1, light1_pos); light1->setAmbient(ambientNull); if (light1On == 0) light1->disable(); else light1->enable(); light2 = new CGFlight(GL_LIGHT2, light2_pos); light2->setAmbient(ambientNull); if (light2On == 0) light2->disable(); else light2->enable(); light3 = new CGFlight(GL_LIGHT3, light3_pos); light3->setAmbient(ambientNull); light3->setSpecular(yellow); light3->setKc(0); light3->setKl(0); light3->setKq(1); if (light3On == 0) light3->disable(); else light3->enable(); // Uncomment below to enable normalization of lighting normal vectors // glEnable (GL_NORMALIZE); //Declares scene elements table = new myTable(); wall = new Plane(); clock = new myClock(); cylinder = new myCylinder(10,10, true); cylinder1 = new myCylinder(10,10,false); robot = new myRobot(10); boardA = new Plane(BOARD_A_DIVISIONS); boardB = new Plane(BOARD_B_DIVISIONS); //Declares materials materialA = new CGFappearance(ambientNull,difA,specA,shininessA); materialB = new CGFappearance(ambientNull,difB,specB,shininessB); //Declares Textures tableAppearence = new CGFappearance(ambientNull,difA,specA,shininessA); tableAppearence->setTexture("table.png"); tableAppearence->setTextureWrap(GL_REPEAT,GL_REPEAT); slidesAppearence = new CGFappearance(ambientNull,difSlides,specSlides,shininessSlides); slidesAppearence->setTexture("slides.png"); slidesAppearence->setTextureWrap(GL_CLAMP,GL_CLAMP); boardAppearence = new CGFappearance(ambientNull,difBoard,specBoard,shininessBoard); boardAppearence->setTexture("board.png"); boardAppearence->setTextureWrap(GL_CLAMP,GL_CLAMP); robotAppearence = new CGFappearance (ambientNull, difA , specA, shininessA); robotAppearence->setTexture("robot1.jpg"); robotAppearence->setTextureWrap(GL_CLAMP,GL_CLAMP); setUpdatePeriod(100); }
////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering // context. void SetupRC() { M3DVector3f vPoints[3] = {{ 0.0f, -0.4f, 0.0f }, { 10.0f, -0.4f, 0.0f }, { 5.0f, -0.4f, -5.0f }}; int iSphere; int i; // Grayish background glClearColor(fLowLight[0], fLowLight[1], fLowLight[2], fLowLight[3]); // Clear stencil buffer with zero, increment by one whenever anybody // draws into it. When stencil function is enabled, only write where // stencil value is zero. This prevents the transparent shadow from drawing // over itself glStencilOp(GL_INCR, GL_INCR, GL_INCR); glClearStencil(0); glStencilFunc(GL_EQUAL, 0x0, 0x01); // Cull backs of polygons glCullFace(GL_BACK); glFrontFace(GL_CCW); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_MULTISAMPLE_ARB); // Setup light parameters glLightModelfv(GL_LIGHT_MODEL_AMBIENT, fNoLight); glLightfv(GL_LIGHT0, GL_AMBIENT, fLowLight); glLightfv(GL_LIGHT0, GL_DIFFUSE, fBrightLight); glLightfv(GL_LIGHT0, GL_SPECULAR, fBrightLight); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); // Calculate shadow matrix M3DVector4f pPlane; m3dGetPlaneEquation(pPlane, vPoints[0], vPoints[1], vPoints[2]); m3dMakePlanarShadowMatrix(mShadowMatrix, pPlane, fLightPos); // Mostly use material tracking glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT, GL_SPECULAR, fBrightLight); glMateriali(GL_FRONT, GL_SHININESS, 128); // Randomly place the sphere inhabitants for(iSphere = 0; iSphere < NUM_SPHERES; iSphere++) { // Pick a random location between -20 and 20 at .1 increments spheres[iSphere].SetOrigin(((float)((rand() % 400) - 200) * 0.1f), 0.0, (float)((rand() % 400) - 200) * 0.1f); } // Set up texture maps glEnable(GL_TEXTURE_2D); glGenTextures(NUM_TEXTURES, textureObjects); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); for(i = 0; i < NUM_TEXTURES; i++) { GLbyte *pBytes; GLint iWidth, iHeight, iComponents; GLenum eFormat; glBindTexture(GL_TEXTURE_2D, textureObjects[i]); // Load this texture map pBytes = gltLoadTGA(szTextureFiles[i], &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } // Create display lists groundList = glGenLists(3); sphereList = groundList + 1; torusList = sphereList + 1; // Create sphere display list glNewList(sphereList, GL_COMPILE); gltDrawSphere(0.1f, 40, 20); glEndList(); // Create torus display list glNewList(torusList, GL_COMPILE); gltDrawTorus(0.35, 0.15, 61, 37); glEndList(); // Create the ground display list glNewList(groundList, GL_COMPILE); DrawGround(); glEndList(); }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int cmdShow) { //Set our window settings const int windowWidth = 1024; const int windowHeight = 768; const int windowBPP = 16; //This is our window static cWNDManager* pgmWNDMgr = cWNDManager::getInstance(); //The example OpenGL code windowOGL theOGLWnd; //Attach our example to our window pgmWNDMgr->attachOGLWnd(&theOGLWnd); // Sphere cSphere theEarth(3,30,30); cSphere theMoon(1, 20, 20); cSphere theSun(6, 60, 60); float rotationAngleEarth = 0; float rotationAngleMoon = 0; //Attempt to create the window if (!pgmWNDMgr->createWND(windowWidth, windowHeight, windowBPP)) { //If it fails MessageBox(NULL, "Unable to create the OpenGL Window", "An error occurred", MB_ICONERROR | MB_OK); pgmWNDMgr->destroyWND(); //Reset the display and exit return 1; } if (!theOGLWnd.initOGL()) //Initialize our example { MessageBox(NULL, "Could not initialize the application", "An error occurred", MB_ICONERROR | MB_OK); pgmWNDMgr->destroyWND(); //Reset the display and exit return 1; } // Crate Texture map cTexture earthTexture; earthTexture.createTexture("Images/Earth.png"); cTexture moonTexture; moonTexture.createTexture("Images/Moon.png"); cTexture sunTexture; sunTexture.createTexture("Images/sun.png"); theSun.initialise(sunTexture.getTexture(), glm::vec3(0, 0, 0), glm::vec3(0, 0, 0)); theEarth.initialise(earthTexture.getTexture(), glm::vec3(30, 0, 0), glm::vec3(0, 0, 0)); float earthRotSpeed = 3.0f; GLfloat earthOrbit = 0.0f; theMoon.initialise(moonTexture.getTexture(), glm::vec3(-3, 0, 8), glm::vec3(0, 0, 0)); float moonRotSpeed = 5.0f; GLfloat moonOrbit = 0.0f; // Create Materials for lights cMaterial sunMaterial(lightColour4(0.0f, 0.0f, 0.0f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(0, 0, 0, 1.0f), 5.0f); cMaterial earthMaterial(lightColour4(0.2f, 0.2f, 0.2f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(0, 0, 0, 1.0f), 50.0f); cMaterial moonMaterial(lightColour4(0.1f, 0.1f, 0.1f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(0.2f, 0.2f, 0.2f, 1.0f), lightColour4(0, 0, 0, 1.0f), 10.0f); // Create Light cLight moonLight(GL_LIGHT0, lightColour4(0, 0, 0, 1), lightColour4(1, 1, 1, 1), lightColour4(1, 1, 1, 1), glm::vec4(0, 0, 20, 1), glm::vec3(0.0, 0.0, 1.0), 0.0f, 180.0f, 1.0f, 0.0f, 0.0f); cLight sunLight(GL_LIGHT0, lightColour4(0, 0, 0, 1), lightColour4(1, 1, 1, 1), lightColour4(1, 1, 1, 1), glm::vec4(0, 0, 20, 1), glm::vec3(0.0, 0.0, 1.0), 0.0f, 180.0f, 1.0f, 0.0f, 0.0f); //Define Ambient light for scene GLfloat g_Ambient[] = { 0.2, 0.2, 0.2, 1.0 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, g_Ambient); //This is the mainloop, we render frames until isRunning returns false while (pgmWNDMgr->isWNDRunning()) { pgmWNDMgr->processWNDEvents(); //Process any window events //We get the time that passed since the last frame float elapsedTime = pgmWNDMgr->getElapsedSeconds(); // Lab code goes here glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); theOGLWnd.initOGL(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0f, 0.0f, -100.0f); glRotatef(-90.0f, 1, 0, 0); // Sun setup sunLight.lightOn(); theSun.setRotAngle(theSun.getRotAngle()); theSun.prepare(theSun.getRotAngle()); sunMaterial.useMaterial(); theSun.render(theSun.getRotAngle()); // Earth's orbit glPushMatrix(); glTranslatef(0, 0, 0); glRotatef(earthOrbit*10, 0.0f, 1.0f, 0.0f); rotationAngleEarth += (earthRotSpeed*elapsedTime); theEarth.setRotAngle(theEarth.getRotAngle() + (earthRotSpeed*elapsedTime)); theEarth.prepare(rotationAngleEarth); //Do any pre-rendering logic earthMaterial.useMaterial(); // Set the material for use theEarth.render(theEarth.getRotAngle()); //Render the scene glPopMatrix(); // Moon's orbit glPushMatrix(); moonLight.lightOn(); glTranslatef(0, 0, 0); glRotatef(earthOrbit*10, 0.0f, 1.0f, 0.0f); glTranslatef(theEarth.getPosition().x, theEarth.getPosition().y, theEarth.getPosition().z); glRotatef(moonOrbit*10, 0.0f, 1.0f, 0.0f); glTranslatef(10.0f, 0.0f, 0.0f); rotationAngleMoon += (moonRotSpeed*elapsedTime); theMoon.setRotAngle(theMoon.getRotAngle() + (moonRotSpeed*elapsedTime)); theMoon.prepare(rotationAngleMoon); moonMaterial.useMaterial(); theMoon.render(theMoon.getRotAngle()); glPopMatrix(); pgmWNDMgr->swapBuffers(); moonOrbit += (5.0f) * elapsedTime; if (moonOrbit > 360.0f) { moonOrbit -= 360.0f; } earthOrbit += (5.0f) * elapsedTime; if (earthOrbit > 360.0f) { earthOrbit -= 360.0f; } } theOGLWnd.shutdown(); //Free any resources pgmWNDMgr->destroyWND(); //Destroy the program window return 0; //Return success }
static void Init(void) { static float ambient[] = {0.1, 0.1, 0.1, 1.0}; static float diffuse[] = {0.5, 1.0, 1.0, 1.0}; static float position[] = {90.0, 90.0, 150.0, 0.0}; static float front_mat_shininess[] = {30.0}; static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0}; static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0}; static float back_mat_shininess[] = {50.0}; static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0}; static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0}; static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0}; static float lmodel_twoside[] = {GL_TRUE}; glClearColor(0.0, 0.0, 0.0, 0.0); glFrontFace(GL_CW); glEnable(GL_DEPTH_TEST); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess); glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular); glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse); glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess); glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular); glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse); glEnable(GL_CLIP_PLANE0); if (rgb) { glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nearest); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nearest); glTexImage2D(GL_TEXTURE_2D, 0, 3, CHECKIMAGEWIDTH, CHECKIMAGEHEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)checkImage); glEnable(GL_TEXTURE_2D); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); } else { SetGreyRamp(); /* commented out by BrianP because it's the wrong way to handle a 4-bit visual! if (doubleBuffer) { colorIndexes[1] = 10; colorIndexes[2] = 15; } */ glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, colorIndexes); } BuildLists(); dithering = GL_TRUE; shade = GL_TRUE; doStipple = GL_FALSE; polyMode = GL_BACK; }
static void Init(void) { float ambient[] = {0.0, 0.0, 0.0, 1.0}; float diffuse[] = {1.0, 1.0, 1.0, 1.0}; float specular[] = {1.0, 1.0, 1.0, 1.0}; float position[] = {0.0, 0.0, 4.0, 0.0}; float fog_color[] = {0.0, 0.0, 0.0, 1.0}; float mat_ambient[] = {0.0, 0.0, 0.0, 1.0}; float mat_shininess[] = {90.0}; float mat_specular[] = {1.0, 1.0, 1.0, 1.0}; float mat_diffuse[] = {0.8, 0.8, 0.8, 1.0}; float lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0}; float lmodel_twoside[] = {GL_TRUE}; int w, h; GLenum format; GLubyte *image; printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); SetDefaultSettings(); image = LoadRGBImage(imageFileName, &w, &h, &format); if (!image) { printf("Error: couldn't load %s\n", imageFileName); exit(1); } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); gluBuild2DMipmaps(GL_TEXTURE_2D, format, w, h, GL_RGB, GL_UNSIGNED_BYTE, image); free(image); glFogf(GL_FOG_DENSITY, 0.125); glFogi(GL_FOG_MODE, GL_LINEAR); glFogf(GL_FOG_START, 4.0); glFogf(GL_FOG_END, 8.5); glFogfv(GL_FOG_COLOR, fog_color); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, specular); glLightfv(GL_LIGHT0, GL_POSITION, position); glEnable(GL_LIGHT0); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glShadeModel(GL_SMOOTH); glClearColor(0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); glFrontFace(GL_CW); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glTexGeniv(GL_S, GL_TEXTURE_GEN_MODE, sphereMap); glTexGeniv(GL_T, GL_TEXTURE_GEN_MODE, sphereMap); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, sWrapMode); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tWrapMode); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textureEnvironment); BuildLists(); }
void UpdateDisplay( void ) { // Get window size glfwGetWindowSize( &width, &height ); // Set viewport glViewport( 0, 0, width, height ); // Clear display glClearColor( 0.02f, 0.02f, 0.02f, 0.0f ); glClearDepth( 1.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Setup projection matrix glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluPerspective( 55.0f, // Angle of view (GLfloat)width/(GLfloat)height, // Aspect 1.0f, // Near Z 100.0f // Far Z ); // Setup modelview matrix glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); switch( camerapos ) { default: case CAMERA_CLASSIC: gluLookAt( 0.0f, 0.0f, 2.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f ); break; case CAMERA_ABOVE: gluLookAt( 0.0f, 0.0f, 2.5f, (float)ball.xpos, (float)ball.ypos, 0.0f, 0.0f, 1.0f, 0.0f ); break; case CAMERA_SPECTATOR: gluLookAt( 0.0f, -2.0, 1.2f, (float)ball.xpos, (float)ball.ypos, 0.0f, 0.0f, 0.0f, 1.0f ); break; } // Enable depth testing glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_LEQUAL ); // Enable lighting glEnable( GL_LIGHTING ); glLightModelfv( GL_LIGHT_MODEL_AMBIENT, env_ambient ); glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE ); glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE ); glLightfv( GL_LIGHT1, GL_POSITION, light1_position ); glLightfv( GL_LIGHT1, GL_DIFFUSE, light1_diffuse ); glLightfv( GL_LIGHT1, GL_AMBIENT, light1_ambient ); glEnable( GL_LIGHT1 ); // Front face is counter-clock-wise glFrontFace( GL_CCW ); // Enable face culling (not necessary, but speeds up rendering) glCullFace( GL_BACK ); glEnable( GL_CULL_FACE ); // Draw Player 1 glMaterialfv( GL_FRONT, GL_DIFFUSE, player1_diffuse ); glMaterialfv( GL_FRONT, GL_AMBIENT, player1_ambient ); DrawBox( -1.f, (GLfloat)player1.ypos-PLAYER_YSIZE, 0.f, -1.f+PLAYER_XSIZE, (GLfloat)player1.ypos+PLAYER_YSIZE, 0.1f ); // Draw Player 2 glMaterialfv( GL_FRONT, GL_DIFFUSE, player2_diffuse ); glMaterialfv( GL_FRONT, GL_AMBIENT, player2_ambient ); DrawBox( 1.f-PLAYER_XSIZE, (GLfloat)player2.ypos-PLAYER_YSIZE, 0.f, 1.f, (GLfloat)player2.ypos+PLAYER_YSIZE, 0.1f ); // Draw Ball glMaterialfv( GL_FRONT, GL_DIFFUSE, ball_diffuse ); glMaterialfv( GL_FRONT, GL_AMBIENT, ball_ambient ); DrawBox( (GLfloat)ball.xpos-BALL_SIZE, (GLfloat)ball.ypos-BALL_SIZE, 0.f, (GLfloat)ball.xpos+BALL_SIZE, (GLfloat)ball.ypos+BALL_SIZE, BALL_SIZE*2 ); // Top game field border glMaterialfv( GL_FRONT, GL_DIFFUSE, border_diffuse ); glMaterialfv( GL_FRONT, GL_AMBIENT, border_ambient ); DrawBox( -1.1f, 1.0f, 0.0f, 1.1f, 1.1f, 0.1f ); // Bottom game field border glColor3f( 0.0f, 0.0f, 0.7f ); DrawBox( -1.1f, -1.1f, 0.0f, 1.1f, -1.0f, 0.1f ); // Left game field border DrawBox( -1.1f, -1.0f, 0.0f, -1.0f, 1.0f, 0.1f ); // Left game field border DrawBox( 1.0f, -1.0f, 0.0f, 1.1f, 1.0f, 0.1f ); // Enable texturing glEnable( GL_TEXTURE_2D ); glBindTexture( GL_TEXTURE_2D, tex_id[ TEX_FIELD ] ); // Game field floor glMaterialfv( GL_FRONT, GL_DIFFUSE, floor_diffuse ); glMaterialfv( GL_FRONT, GL_AMBIENT, floor_ambient ); DrawBox( -1.01f, -1.01f, -0.01f, 1.01f, 1.01f, 0.0f ); // Disable texturing glDisable( GL_TEXTURE_2D ); // Disable face culling glDisable( GL_CULL_FACE ); // Disable lighting glDisable( GL_LIGHTING ); // Disable depth testing glDisable( GL_DEPTH_TEST ); }
void Scene::init(){ glClearColor(graph->background[0], graph->background[1], graph->background[2], graph->background[3]); //inicializar o vector de cameras da Scene map<string, Camera*>::iterator it; for(it=graph->cameras.begin(); it != graph->cameras.end(); it++){ cameras.push_back((*it).second); } camIt = cameras.begin(); for(int i = 0; camIt != cameras.end(); i++,it++) { if((*camIt)->id == graph->rootCamera) { actualCam = i; break; } } glEnable(GL_NORMALIZE); if(graph->cullingFace == "none") glCullFace(GL_NONE); else if(graph->cullingFace == "back") glCullFace(GL_BACK); else if(graph->cullingFace == "front") glCullFace(GL_FRONT); else if(graph->cullingFace == "both") glCullFace(GL_FRONT_AND_BACK); if(graph->cullingOrder == "ccw") glFrontFace(GL_CCW); else if(graph->cullingOrder == "cw") glFrontFace(GL_CW); //lighting if(graph->lEnabled) glEnable(GL_LIGHTING); if(graph->lDoubleSided){ glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); }else{ glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); } if(graph->lLocal) glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE); else{ glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_FALSE); } //ambient light float ambientLight[4] = {0,0,0,0}; for(int i = 0; i < 4;i++) ambientLight[i] = graph->lAmbient[i]; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight); if(graph->shading == "gouraud") glShadeModel(GL_SMOOTH); else if(graph->shading == "flat") glShadeModel(GL_FLAT); if(graph->drawingMode == "fill") wire = 0; else if(graph->drawingMode == "line") wire = 1; else if(graph->drawingMode == "point") wire = 2; vector<Light> lghts = graph->lights; int i = 0; vector<Light>::iterator lIt; for(lIt = lghts.begin(); lIt != lghts.end(); lIt++,i++){ float pos[4] = {lIt->pos[0], lIt->pos[1], lIt->pos[2], 1.0}; float ambient[4] = {lIt->ambient[0], lIt->ambient[1], lIt->ambient[2], lIt->ambient[3]}; float diffuse[4] = {lIt->diffuse[0], lIt->diffuse[1], lIt->diffuse[2], lIt->diffuse [3]}; float specular[4] = {lIt->specular[0], lIt->specular[1], lIt->specular[2], lIt->specular[3]}; CGFlight* newLight; if( lIt->type == "spot") { float angle = lIt->angle, exp = lIt->exponent; float target[3]={lIt->target[0]-pos[0], lIt->target[1]-pos[1], lIt->target[2]-pos[2]}; float unit = sqrt(target[0] * target[0] + target[1] * target[1] + target[2] * target[2]); for (int i = 0; i < 3; i++) target[i] = target[i] / unit; glLightf(lightsArray[i],GL_SPOT_EXPONENT,exp); glLightf(lightsArray[i],GL_SPOT_CUTOFF,angle); glLightfv(lightsArray[i],GL_SPOT_DIRECTION,target); newLight = new CGFlight(lightsArray[i],pos,target); } else newLight =new CGFlight(lightsArray[i],pos); newLight->setAmbient(ambient); newLight->setDiffuse(diffuse); newLight->setSpecular(specular); if(lIt->enabled) newLight->enable(); else newLight->disable(); newLight->update(); lights.push_back(newLight); } }
// apply light // Set them from light nodes if possible. // If not, use the light objects directly. void x3ds_instance::set_light() { glLightModelfv(GL_LIGHT_MODEL_AMBIENT, m_def->m_file->ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glShadeModel(GL_SMOOTH); Lib3dsLight* l = m_def->m_file->lights; for (int gl_light = GL_LIGHT0; gl_light <= GL_LIGHT7; gl_light++) { if (l) { glEnable(gl_light); // default we use light objects directly GLfloat color[4]; color[0] = l->color[0]; color[1] = l->color[1]; color[2] = l->color[2]; color[3] = 1; // default position GLfloat position[4]; position[0] = l->position[0]; position[1] = l->position[1]; position[2] = l->position[2]; position[3] = 1; // try light nodes if possible Lib3dsNode* ln = lib3ds_file_node_by_name(m_def->m_file, l->name, LIB3DS_LIGHT_NODE); if (ln) { color[0] = ln->data.light.col[0]; color[1] = ln->data.light.col[1]; color[2] = ln->data.light.col[2]; position[0] = ln->data.light.pos[0]; position[1] = ln->data.light.pos[1]; position[2] = ln->data.light.pos[2]; } // try spot nodes if possible Lib3dsNode* sn = lib3ds_file_node_by_name(m_def->m_file, l->name, LIB3DS_SPOT_NODE); if (sn) { l->spot[0] = sn->data.spot.pos[0]; l->spot[1] = sn->data.spot.pos[1]; l->spot[2] = sn->data.spot.pos[2]; } static const GLfloat a[] = {0.0f, 0.0f, 0.0f, 1.0f}; glLightfv(gl_light, GL_AMBIENT, a); glLightfv(gl_light, GL_DIFFUSE, color); glLightfv(gl_light, GL_SPECULAR, color); glLightfv(gl_light, GL_POSITION, position); glLightf(gl_light, GL_LINEAR_ATTENUATION, l->attenuation); // glLightf(gl_light, GL_CONSTANT_ATTENUATION, 0); // glLightf(gl_light, GL_QUADRATIC_ATTENUATION, 0); if (l->spot_light) { position[0] = l->spot[0]; position[1] = l->spot[1]; position[2] = l->spot[2]; glLightfv(gl_light, GL_SPOT_DIRECTION, position); glLightf(gl_light, GL_SPOT_CUTOFF, l->fall_off); glLightf(gl_light, GL_SPOT_EXPONENT, 0); // hack } l = l->next; } else { glDisable(gl_light); } } glEnable(GL_LIGHTING); }
/* static */ void px_vp20Utils::unsetLightingGL(const MHWRender::MDrawContext& context) { MStatus status; // Take into account only the 8 lights supported by the basic // OpenGL profile. const unsigned int nbLights = std::min(context.numberOfActiveLights(&status), 8u); if (status != MStatus::kSuccess) return; // Restore OpenGL default values for anything that we have // modified. if (nbLights > 0) { for (unsigned int i=0; i<nbLights; ++i) { glDisable(GL_LIGHT0+i); const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient); if (i==0) { const GLfloat diffuse[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse); const GLfloat spec[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; glLightfv(GL_LIGHT0+i, GL_SPECULAR, spec); } else { const GLfloat diffuse[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse); const GLfloat spec[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glLightfv(GL_LIGHT0+i, GL_SPECULAR, spec); } const GLfloat pos[4] = { 0.0f, 0.0f, 1.0f, 0.0f }; glLightfv(GL_LIGHT0+i, GL_POSITION, pos); const GLfloat dir[3] = { 0.0f, 0.0f, -1.0f }; glLightfv(GL_LIGHT0+i, GL_SPOT_DIRECTION, dir); glLightf(GL_LIGHT0+i, GL_SPOT_EXPONENT, 0.0); glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0); } glDisable(GL_LIGHTING); glDisable(GL_COLOR_MATERIAL) ; glDisable(GL_NORMALIZE) ; const GLfloat ambient[4] = { 0.2f, 0.2f, 0.2f, 1.0f }; const GLfloat specular[4] = { 0.8f, 0.8f, 0.8f, 1.0f }; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0); } }
void myinit(void) { /*Initialize and compute the vectors for the spiral*/ spir[0][0]=0.0; spir[0][1]=-1.0; spir[1][0]=-sin(30.0*M_PI/180); spir[1][1]=-cos(30.0*M_PI/180); spir[2][0]=-cos(30.0*M_PI/180); spir[2][1]=-sin(30.0*M_PI/180); spir[3][0]=-1.0; spir[3][1]=0.0; spir[4][0]=-cos(30.0*M_PI/180); spir[4][1]=sin(30.0*M_PI/180); spir[5][0]=-sin(30.0*M_PI/180); spir[5][1]=cos(30.0*M_PI/180); spir[6][0]=0.0; spir[6][1]=1.0; spir[7][0]=sin(30.0*M_PI/180); spir[7][1]=cos(30.0*M_PI/180); spir[8][0]=cos(30.0*M_PI/180); spir[8][1]=sin(30.0*M_PI/180); spir[9][0]=1.0; spir[9][1]=0; spir[10][0]=cos(30.0*M_PI/180); spir[10][1]=-sin(30.0*M_PI/180); spir[11][0]=sin(30.0*M_PI/180); spir[11][1]=-cos(30.0*M_PI/180); for (int i = 0; i <= 103; i++) { cosTable[i] = cos((double)(M_PI*2*i/100.0)); sinTable[i] = sin((double)(M_PI*2*i/100.0)); } /*create all needed spheres and initialize them with default values*/ initializeSpheres(); /*Initialize the random number creator*/ time_t t; time(&t); srand((unsigned int)t); //initialize with date and time /* attributes */ glClearColor(0.0, 0.0, 0.0, 1.0); /* black background */ /* Lighting */ glLoadIdentity(); GLfloat light_ambient[] = {0.0,0.0,0.0,1.0}; GLfloat light_diffuse[] = {1.0,1.0,1.0,1.0}; GLfloat light_specular[] = {1.0,1.0,1.0,1.0}; GLfloat lmodel_ambient[] = {0.5,0.5,0.5,1.0}; GLfloat mat_amb_diff[] = { 0.5, 0.5, 0.5, 1.0 }; GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_shininess[] = { 40.0 }; GLfloat light_position0[] = {1.0, 1.0, 0.0, 0.0 }; glShadeModel (GL_SMOOTH); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position0); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); //Enable Lighting glEnable(GL_COLOR_MATERIAL); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); }
PXR_NAMESPACE_OPEN_SCOPE /* static */ bool px_vp20Utils::setupLightingGL(const MHWRender::MDrawContext& context) { MStatus status; // Take into account only the 8 lights supported by the basic // OpenGL profile. const unsigned int nbLights = std::min(context.numberOfActiveLights(&status), 8u); if (status != MStatus::kSuccess) return false; if (nbLights > 0) { // Lights are specified in world space and needs to be // converted to view space. glMatrixMode(GL_MODELVIEW); glPushMatrix(); const MMatrix worldToView = context.getMatrix(MHWRender::MDrawContext::kViewMtx, &status); if (status != MStatus::kSuccess) return false; glLoadMatrixd(worldToView.matrix[0]); glEnable(GL_LIGHTING); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL) ; glEnable(GL_NORMALIZE) ; { const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; const GLfloat specular[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1); } for (unsigned int i=0; i<nbLights; ++i) { MFloatVector direction; float intensity; MColor color; bool hasDirection; bool hasPosition; #if MAYA_API_VERSION >= 201300 // Starting with Maya 2013, getLightInformation() uses MFloatPointArray for positions MFloatPointArray positions; status = context.getLightInformation( i, positions, direction, intensity, color, hasDirection, hasPosition); const MFloatPoint &position = positions[0]; #else // Maya 2012, getLightInformation() uses MFloatPoint for position MFloatPoint position; status = context.getLightInformation( i, position, direction, intensity, color, hasDirection, hasPosition); #endif if (status != MStatus::kSuccess) return false; if (hasDirection) { if (hasPosition) { // Assumes a Maya Spot Light! const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; const GLfloat diffuse[4] = { intensity * color[0], intensity * color[1], intensity * color[2], 1.0f }; const GLfloat pos[4] = { position[0], position[1], position[2], 1.0f }; const GLfloat dir[3] = { direction[0], direction[1], direction[2]}; glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0+i, GL_POSITION, pos); glLightfv(GL_LIGHT0+i, GL_SPOT_DIRECTION, dir); // Maya's default value's for spot lights. glLightf(GL_LIGHT0+i, GL_SPOT_EXPONENT, 0.0); glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 20.0); } else { // Assumes a Maya Directional Light! const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; const GLfloat diffuse[4] = { intensity * color[0], intensity * color[1], intensity * color[2], 1.0f }; const GLfloat pos[4] = { -direction[0], -direction[1], -direction[2], 0.0f }; glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0+i, GL_POSITION, pos); glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0); } } else if (hasPosition) { // Assumes a Maya Point Light! const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; const GLfloat diffuse[4] = { intensity * color[0], intensity * color[1], intensity * color[2], 1.0f }; const GLfloat pos[4] = { position[0], position[1], position[2], 1.0f }; glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0+i, GL_POSITION, pos); glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0); } else { // Assumes a Maya Ambient Light! const GLfloat ambient[4] = { intensity * color[0], intensity * color[1], intensity * color[2], 1.0f }; const GLfloat diffuse[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; const GLfloat pos[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0+i, GL_POSITION, pos); glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0); } glEnable(GL_LIGHT0+i); } glPopMatrix(); } glDisable(GL_LIGHTING); return nbLights > 0; }
void inicializacao() { // inicialização de apontador para quádricas glQ = gluNewQuadric(); glFrontFace(GL_CCW); // Front faces defined using a counterclockwise rotation glDepthFunc(GL_LEQUAL); // Por defeito e GL_LESS glEnable(GL_DEPTH_TEST); // Use a depth (z) buffer to draw only visible objects // Face Culling para aumentar a velocidade glEnable(GL_CULL_FACE); //glCullFace(GL_BACK); // GL_FRONT, GL_BACK, GL_FRONT_AND_BACK // Define que modelo de iluminacao utilizar; consultar o manual de referencia glLightModelfv(GL_LIGHT_MODEL_AMBIENT, light_ambient); // define luz ambiente glLightModelf (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, 1); // por defeito a cor de fundo e o preto // glClearColor(1.0,1.0,1.0,1.0); // cor de fundo a branco // declaracoes para a fonte luz GL_LIGHT0 glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular); glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, light0_kc); glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, light0_kl); glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, light0_kq); // declaracoes para a fonte luz GL_LIGHT1 glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular); glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, light1_kc); glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, light1_kl); glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, light1_kq); // Permitir calculos de iluminacao glEnable(GL_LIGHTING); // "Acender" a fonte de luz GL_LIGHT0 glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); // Declaracoe para shading glShadeModel(GL_SMOOTH); // GL_FLAT / GL_SMOOTH glPolygonMode(GL_FRONT, GL_FILL); // preence a face da frente dos poligonos //glPolygonMode(GL_FRONT, GL_LINE); // desenha arestas dos poligonos pixmap.readBMPFile("newspaper.bmp"); pixmap.setTexture(TX_NEWSPAPER); pixmap.readBMPFile("paisagem.bmp"); pixmap.setTexture(TX_LANDSCAPE); pixmap.readBMPFile("metal.bmp"); pixmap.setTexture(TX_METAL); pixmap.readBMPFile("wood_machine.bmp"); pixmap.setTexture(TX_WOOD_MACHINE); pixmap.readBMPFile("wood.bmp"); pixmap.setTexture(TX_WOOD_BELT); pixmap.readBMPFile("belt.bmp"); pixmap.setTexture(TX_BELT); pixmap.readBMPFile("floor.bmp"); pixmap.setTexture(TX_FLOOR); pixmap.readBMPFile("guillotine.bmp"); pixmap.setTexture(TX_GUILLOTINE); pixmap.readBMPFile("wall.bmp"); pixmap.setTexture(TX_WALL); glNewList(DP_GEOMETRY,GL_COMPILE); impostors(); myRoom(roomX,roomY,roomZ,windowYi,windowYf,windowZi,windowZf,doorXi,doorXf,doorY,curvedXHeight,curvedNSlices,curvedYSlices); glEndList(); glNewList(DP_MACHINE,GL_COMPILE); printingMachine(printingMachineX,printingMachineZ); glEndList(); glNewList(DP_ROBOT,GL_COMPILE); robot(robotY); glEndList(); }
//Called to draw scene void Display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); //use gluLookAt to look at torus gluLookAt( 0.0f,10.0f,10.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); //rotate torus static float angle=0.0f; angle+=0.1f; glRotatef(angle, 0.0f, 1.0f, 0.0f); //Get the inverse model matrix MATRIX4X4 inverseModelMatrix; glPushMatrix(); glLoadIdentity(); glRotatef(-angle, 0.0f, 1.0f, 0.0f); glGetFloatv(GL_MODELVIEW_MATRIX, inverseModelMatrix); glPopMatrix(); //Get the object space light vector VECTOR3D objectLightPosition=inverseModelMatrix*worldLightPosition; //Loop through vertices for(int i=0; i<torus.numVertices; ++i) { VECTOR3D lightVector=objectLightPosition-torus.vertices[i].position; //Calculate tangent space light vector torus.vertices[i].tangentSpaceLight.x= torus.vertices[i].sTangent.DotProduct(lightVector); torus.vertices[i].tangentSpaceLight.y= torus.vertices[i].tTangent.DotProduct(lightVector); torus.vertices[i].tangentSpaceLight.z= torus.vertices[i].normal.DotProduct(lightVector); } //Draw bump pass if(drawBumps) { //Bind normal map to texture unit 0 glBindTexture(GL_TEXTURE_2D, normalMap); glEnable(GL_TEXTURE_2D); //Bind normalisation cube map to texture unit 1 glActiveTexture(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap); glEnable(GL_TEXTURE_CUBE_MAP_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); //Set vertex arrays for torus glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position); glEnableClientState(GL_VERTEX_ARRAY); //Send texture coords for normal map to unit 0 glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s); glEnableClientState(GL_TEXTURE_COORD_ARRAY); //Send tangent space light vectors for normalisation to unit 1 glClientActiveTexture(GL_TEXTURE1_ARB); glTexCoordPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].tangentSpaceLight); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTexture(GL_TEXTURE0_ARB); //Set up texture environment to do (tex0 dot tex1)*color glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); glActiveTextureARB(GL_TEXTURE1_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); //Draw torus glDrawElements(GL_TRIANGLES, torus.numIndices, GL_UNSIGNED_INT, torus.indices); //Disable textures glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_CUBE_MAP_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); //disable vertex arrays glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTexture(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTexture(GL_TEXTURE0_ARB); //Return to standard modulate texenv glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } //If we are drawing both passes, enable blending to multiply them together if(drawBumps && drawColor) { //Enable multiplicative blending glBlendFunc(GL_DST_COLOR, GL_ZERO); glEnable(GL_BLEND); } //Perform a second pass to color the torus if(drawColor) { if(!drawBumps) { glLightfv(GL_LIGHT1, GL_POSITION, VECTOR4D(objectLightPosition)); glLightfv(GL_LIGHT1, GL_DIFFUSE, white); glLightfv(GL_LIGHT1, GL_AMBIENT, black); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black); glEnable(GL_LIGHT1); glEnable(GL_LIGHTING); glMaterialfv(GL_FRONT, GL_DIFFUSE, white); } //Bind decal texture glBindTexture(GL_TEXTURE_2D, decalTexture); glEnable(GL_TEXTURE_2D); //Set vertex arrays for torus glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position); glEnableClientState(GL_VERTEX_ARRAY); glNormalPointer(GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].normal); glEnableClientState(GL_NORMAL_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s); glEnableClientState(GL_TEXTURE_COORD_ARRAY); //Draw torus glDrawElements(GL_TRIANGLES, torus.numIndices, GL_UNSIGNED_INT, torus.indices); if(!drawBumps) glDisable(GL_LIGHTING); //Disable texture glDisable(GL_TEXTURE_2D); //disable vertex arrays glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); } //Disable blending if it is enabled if(drawBumps && drawColor) glDisable(GL_BLEND); glFinish(); glutSwapBuffers(); glutPostRedisplay(); }
DRReturn render(float fTime) { glViewport(0, 0, g_pSDLWindow->w, g_pSDLWindow->h); glClearColor(0.1, 0.2, 0.0, 0); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColor3f(0.0f, 0.0f, 0.0f); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); glEnable(GL_CULL_FACE); //if(g_terrain) // g_terrain->bind(); //if(g_Player.getSektor()->renderAll(fTime, g_Player.getCamera())) if(wireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); if(g_Player.getSektor()->renderAll(fTime, g_Player.getCamera())) LOG_ERROR("Fehler bei render sektor", DR_ERROR); ShaderProgram::unbind(); glDisable(GL_LIGHTING); glEnable(GL_CULL_FACE); glClear (GL_DEPTH_BUFFER_BIT); glColor3f(1.0f, 1.0f, 1.0f); //Reseten der Matrixen glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); //gluPerspective(g_Player.getCameraFOV(), (GLfloat)XWIDTH/(GLfloat)YHEIGHT, 0.1f, 2000.0f); glMultMatrixf(DRMatrix::perspective_projection(g_Player.getCameraFOV(), (GLfloat)XWIDTH/(GLfloat)YHEIGHT, 0.1f, 2000.0f)); DRFrustumCulling cull(g_cam, g_Player.getCameraFOV(), (GLfloat)XWIDTH/(GLfloat)YHEIGHT, 0.1f, 1000.0f); glMatrixMode(GL_MODELVIEW); // Select the modelview matrix glLoadIdentity(); // Reset (init) the modelview matrix DRVector3 translate(0.0f); g_cam->setKameraMatrix(); glEnable(GL_DEPTH_TEST); // Enables depth test //light //Add ambient light GLfloat ambientColor[] = {0.4f, 0.4f, 0.4f, 1.0f}; //Color(0.2, 0.2, 0.2) glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor); //Add positioned light GLfloat lightColor0[] = {1.0f, 1.0f, 1.0f, 1.0f}; //Color (0.5, 0.5, 0.5) GLfloat lightPos0[] = {4.0f, 0.0f, 8.0f, 1.0f}; //Positioned at (4, 0, 8) glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0); glLightfv(GL_LIGHT0, GL_POSITION, lightPos0); glDisable(GL_LIGHT0); //Add directed light GLfloat lightColor1[] = {0.5f, 0.5f, 0.5f, 1.0f}; //Color (0.5, 0.2, 0.2) //Coming from the direction (-1, 0.5, 0.5) GLfloat lightPos1[] = {-1.0f, 0.5f, 0.5f, 0.0f}; glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1); glLightfv(GL_LIGHT1, GL_POSITION, lightPos1); glEnable(GL_LIGHT1); if(g_tex.getResourcePtrHolder()) g_tex->bind(); //glColor3f(0.2f, 0.5f, 0.1f); /* glColor3f(1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); glTexCoord2f(1.0, 0.0f); glVertex3f( 50.0f, 0.0f, -50.0f); glTexCoord2f(0.0, 0.0f); glVertex3f(-50.0f, 0.0f, -50.0f); glTexCoord2f(0.0, 1.0f); glVertex3f(-50.0f, 0.0f, 50.0f); glTexCoord2f(1.0, 1.0f); glVertex3f( 50.0f, 0.0f, 50.0f); glEnd(); //glDisable(GL_TEXTURE_2D); glTranslatef(0.0f, 2.0f, 0.0f); glBegin(GL_QUADS); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(1.0f, 0.0f, 0.0f); glVertex3f(-1.0f, 0.0f, 0.0f); glVertex3f(-1.0f, 0.0f, -1.0f); glVertex3f(1.0f, 0.0f, 0.0f); glEnd(); glTranslatef(0.0f, -2.0f, 0.0f); // printf("bevore renderBlock\n"); glTranslatef(0.0f, 10.0f, 0.0f); translate.y += 10.0f; //*/ RenderBlock* rb = g_RenderBlockLoader.getRenderBlock("dirt"); /* rb->render(); glTranslatef(0.0f, -5.0f, 0.0f); translate.y -= 5.0f; rb = g_RenderBlockLoader.getRenderBlock("dirG"); rb->render(); glTranslatef(1.0f, 0.0f, 0.0f); translate.x += 1.0f; rb->render(); glTranslatef(0.0f, 2.0f, 0.0f); translate.y += 2.0f; DRFrustumPosition res = cull.isBoxInFrustum(DRVector3(-0.5f), DRVector3(0.5f), DRMatrix::translation(translate)); if(res != OUTSIDE) g_RenderBlockLoader.getRenderBlock("benc")->render(); glDisable(GL_TEXTURE_2D); //glDisable(GL_LIGHTING); //*/ static u32 start = 0; float dir[] = {1.0f, 1.0f}; int y = 0; const int length = 250; int clipCount = 0; int renderCount = 0; for(int i = 0; i < blockCount; i++) { if(!(i % 10)) { glTranslatef(0.0f, 1.0f, 0.0f); translate.y += 1.0f; if(cull.isSphereInFrustum(translate, 0.6f) != OUTSIDE) { rb->render(); renderCount++; } else clipCount++; glTranslatef(0.0f, -1.0f, 0.0f); translate.y -= 1.0f; } if(!(i % length)) { if(!(y % length)) { glTranslatef(0.0f, 1.0f, 0.0f); translate.y += 1.0f; dir[1] *= -1.0f; dir[0] *= -1.0f; } else { glTranslatef(0.0f, 0.0f, 1.0f*dir[1]); translate.z += 1.0f*dir[1]; dir[0] *= -1.0f; } y++; } else { glTranslatef(1.0f*dir[0], 0.0f, 0.0f); translate.x += 1.0f*dir[0]; } if(cull.isSphereInFrustum(translate, 0.6f) != OUTSIDE) { rb->render(); renderCount++; } else clipCount++; } u32 end = SDL_GetTicks(); //FPS g_Font->begin(); DRText text(g_Font); text.setFlags(DR_FF_RELATIVE | DR_FF_RELATIVSCALING); text.setText("FPS: %.0f", 1.0f/fTime); text.setPosition(DRVector2(0.0f, 0.0f)); text.setColor12(DRColor(0.8f, 0.5f, 0.1f)); text.setScaling(DRVector2(1.0f)); text.drawText(); text.setText("Count: %d", blockCount); text.setPosition(DRVector2(0.0f, 0.04f)); text.drawText(); text.setText("milliseconds: %u", end-start); text.setPosition(DRVector2(0.1f, 0.0f)); text.drawText(); text.setText("Steuerung: %d - %s/s", gCurrentControlMode+1, gControlModes[gCurrentControlMode].mValue.print().data()); text.setPosition(DRVector2(0.0f, 0.08f)); text.drawText(); GlobalRenderer& gb = GlobalRenderer::Instance(); DRTextureManager& tx = DRTextureManager::Instance(); text.setColor12(DRColor(1.0f, 1.0f, 1.0f)); text.setScaling(DRVector2(0.8f)); text.setText("Grafik Memory: %.0f MByte", static_cast<double>(tx.getGrafikMemoryTexture()+gb.getGrafikMemoryGeometrie())/(1024.0f*1024.0)); text.setPosition(DRVector2(0.8f, 0.0f)); text.drawText(); text.setText("Texture: %.0f MByte", static_cast<double>(tx.getGrafikMemoryTexture())/(1024.0f*1024.0)); text.setPosition(DRVector2(0.8f, 0.04f)); text.drawText(); text.setText("Geometrie: %.0f MByte",static_cast<double>(gb.getGrafikMemoryGeometrie())/(1024.0f*1024.0)); text.setPosition(DRVector2(0.8f, 0.08f)); text.drawText(); g_Font->end(); start = SDL_GetTicks(); if(GlobalRenderer::Instance().renderTasks()) LOG_ERROR("Fehler bei calling GlobalRenderer::renderTasks", DR_ERROR); return DR_OK; }
int main ( int argc, char** argv ) { // Initialize world. DYN_initialize(&world, 0.02); { DYN_Body body; DYN_BodyStaticAttributes attributes; double nullVector[3] = {0, 0, 0}; double identity[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 }; // double impulse[3] = {100, 0, 0}; // double pointOfImpulse[3] = {0, 1, 1}; attributes.shape = DYN_BS_CUBOID; attributes.cuboidAttributes.width = 3; attributes.cuboidAttributes.height = 3; attributes.cuboidAttributes.depth = 3; DYN_calculateMass(&attributes, 1); memcpy(body.position, nullVector, sizeof(nullVector)); memcpy(body.velocity, nullVector, sizeof(nullVector)); memcpy(body.angularVelocity, nullVector, sizeof(nullVector)); memcpy(body.orientation, identity, sizeof(identity)); DYN_addBody(&world, &body, &attributes); //applyImpulse(&world, &world.bodies[0], pointOfImpulse, impulse); /* attributes.cuboidAttributes.width = 1; attributes.cuboidAttributes.height = 1; attributes.cuboidAttributes.depth = 1; DYN_calculateMass(&attributes, 1); body.position[0] = 0; body.position[1] = 0; body.position[2] = -100; body.velocity[2] = 1; DYN_addBody(&world, &body, &attributes);*/ { int i,j,k; attributes.cuboidAttributes.width = 3; attributes.cuboidAttributes.height = 3; attributes.cuboidAttributes.depth = 3; DYN_calculateMass(&attributes, 1); for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { for (k = 0; k < 4; k++) { body.position[0] = 10 + 5*i; body.position[1] = 10 + 5*j; body.position[2] = 10 + 5*k; memcpy(body.velocity, nullVector, sizeof(nullVector)); DYN_addBody(&world, &body, &attributes); } } } } } // initialize SDL video if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { printf( "Unable to init SDL: %s\n", SDL_GetError() ); return 1; } // make sure SDL cleans up before exit atexit(SDL_Quit); // Setting OpenGL attributes SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 ); SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // create a new window SDL_Surface* screen = SDL_SetVideoMode(RESOLUTION_X, RESOLUTION_Y, 16, SDL_HWSURFACE | SDL_OPENGL); // Lock mouse in SDL_ShowCursor(0); //SDL_WM_GrabInput(SDL_GRAB_ON); //< Toggle this // Create display lists createDisplayLists(); // Initialize modes glEnable(GL_DEPTH_TEST); glEnable(GL_COLOR_MATERIAL); // Initialize gl matrixes glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60, 4.0/3.0, 1, 100000.0); // Initlalize GL lights { GLfloat ambient[4] = {0.1, 0.1, 0.1, 1}; GLfloat diffuseColor[4] = {1, 1, 1, 1}; GLfloat specularColor[4] = {0,0,0,0}; glEnable(GL_LIGHTING); glEnable(GL_CULL_FACE); glEnable(GL_LIGHT0); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glMatrixMode(GL_MODELVIEW); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseColor); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_SPECULAR, specularColor); glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0); } if ( !screen ) { printf("Unable to set 640x480 video: %s\n", SDL_GetError()); return 1; } // program main loop while (!handleEvents()) { // message processing loop DYN_stepWorld(&world); controlView(); draw(); usleep(20000); // finally, update the screen SDL_GL_SwapBuffers(); } // end main loop // all is well ;) printf("Exited cleanly\n"); return 0; }
void LightingScene::init() { // Enables lighting computations glEnable(GL_LIGHTING); // Sets up some lighting parameters // Computes lighting only using the front face normals and materials glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); // Define ambient light (do not confuse with ambient component of individual lights) glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbientLight); //glShadeModel(GL_FLAT); // Declares and enables two lights, with null ambient component light0 = new CGFlight(GL_LIGHT0, light0_pos); light0->setAmbient(ambientNull); light0->disable(); light0->setSpecular(yellow); light0->enable(); light1 = new CGFlight(GL_LIGHT1, light1_pos); light1->setAmbient(ambientNull); light1->disable(); light1->enable(); light2 = new CGFlight(GL_LIGHT2, light2_pos); light2->setAmbient(ambientNull); light2->disable(); light2->setKc(0); light2->setKl(1); light2->setKq(0); light2->enable(); light3 = new CGFlight(GL_LIGHT3, light3_pos); light3->setAmbient(ambientNull); light3->disable(); light3->setKc(0); light3->setKl(0); light3->setKq(0.2); light3->enable(); // Uncomment below to enable normalization of lighting normal vectors glEnable (GL_NORMALIZE); //Declares scene elements robot = new MyRobot(180,4,4,7); sceneVar=0; t = CGFapplication::getTime(); aviao=new MyPaperPlane(90,4,4,8); clock1= new MyClock(); table = new myTable(); floor = new Plane(10, 0, 0, 0 , 0, 2); wallWindow = new Plane(10, 0, 16,0-3.5, 8.53-3.5,1); wall = new Plane(10, 0, 16,0-3.5, 8.53-3.5,1); boardA = new Plane(BOARD_A_DIVISIONS,0, 512, 0, 512); boardB = new Plane(BOARD_B_DIVISIONS,0, 512, 0-70, 372-70); //Declares materials materialA = new CGFappearance(ambA,difA,specA,shininessA); materialB = new CGFappearance(ambB,difB,specB,shininessB); slidesAppearance = new CGFappearance(ambSA,difSA,specSA,shininessSA); slidesAppearance->setTexture("slides.png"); boardAppearance = new CGFappearance(ambBA,difBA,specBA,shininessBA); boardAppearance->setTexture("board.png"); boardAppearance->setTextureWrap(GL_CLAMP,GL_CLAMP); windowAppearance = new CGFappearance(ambW,difW,specW,shininessW); windowAppearance->setTexture("window.png"); windowAppearance->setTextureWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE); floorAppearance = new CGFappearance(ambF,difF,specF,shininessF); floorAppearance->setTexture("floor.png"); floorAppearance->setTextureWrap(GL_REPEAT, GL_REPEAT); setUpdatePeriod(100); }
void GLWidget::initializeGL() { initializeOpenGLFunctions(); glClearColor(0.8, 0.8, 0.8, 0); glEnable(GL_DEPTH_TEST); glFrontFace(GL_CW); glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); glEnable(GL_COLOR_MATERIAL); //WE ADD THE LIGHTS glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_LIGHT2); //glEnable(GL_LIGHT3); //Light 1 is a point light, an omni light float lightColor[4] = { 0.5, 0.5, 0.5, 1 }; glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor); //Light 2 a blue keylight float lightColor2[4] = { 0.5, 0.5, 0.5, 1 }; glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor2); //Light 3 is just above the face float lightColor3[4] = { 1.3, 1.3, 1.3, 1 }; glLightfv(GL_LIGHT2, GL_DIFFUSE, lightColor3); /*float lightColor4[4] = { 0.3, 0.3, 0.3, 1 }; float specReflection[] = { 0.3f, 0.3f, 0.3f, 1.0f }; glMaterialfv(GL_BACK, GL_SPECULAR, specReflection); glMateriali(GL_BACK, GL_SHININESS, 56); glLightfv(GL_LIGHT3, GL_SPECULAR, lightColor4);*/ //ambient light GLfloat ambientColor[] = { 0.2f, 0.2f, 0.2f, 1.0f }; //Color(0.2, 0.2, 0.2) glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor); /*glEnable(GL_CULL_FACE); glCullFace(GL_FRONT);*/ readBackgroundImage(); glShadeModel(GL_SMOOTH); generatingMesh = false; //Activar el calculo de transparencias glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glClearColor(0.0, 0.0, 0.0, 0); }
static void pinit(ModeInfo * mi) { morph3dstruct *mp = &morph3d[MI_SCREEN(mi)]; glClearDepth(1.0); glColor3f(1.0, 1.0, 1.0); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glShadeModel(GL_SMOOTH); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular); switch (mp->object) { case 2: mp->draw_object = draw_cube; mp->MaterialColor[0] = MaterialRed; mp->MaterialColor[1] = MaterialGreen; mp->MaterialColor[2] = MaterialCyan; mp->MaterialColor[3] = MaterialMagenta; mp->MaterialColor[4] = MaterialYellow; mp->MaterialColor[5] = MaterialBlue; mp->edgedivisions = cubedivisions; mp->Magnitude = 2.0; break; case 3: mp->draw_object = draw_octa; mp->MaterialColor[0] = MaterialRed; mp->MaterialColor[1] = MaterialGreen; mp->MaterialColor[2] = MaterialBlue; mp->MaterialColor[3] = MaterialWhite; mp->MaterialColor[4] = MaterialCyan; mp->MaterialColor[5] = MaterialMagenta; mp->MaterialColor[6] = MaterialGray; mp->MaterialColor[7] = MaterialYellow; mp->edgedivisions = octadivisions; mp->Magnitude = 2.5; break; case 4: mp->draw_object = draw_dodeca; mp->MaterialColor[0] = MaterialRed; mp->MaterialColor[1] = MaterialGreen; mp->MaterialColor[2] = MaterialCyan; mp->MaterialColor[3] = MaterialBlue; mp->MaterialColor[4] = MaterialMagenta; mp->MaterialColor[5] = MaterialYellow; mp->MaterialColor[6] = MaterialGreen; mp->MaterialColor[7] = MaterialCyan; mp->MaterialColor[8] = MaterialRed; mp->MaterialColor[9] = MaterialMagenta; mp->MaterialColor[10] = MaterialBlue; mp->MaterialColor[11] = MaterialYellow; mp->edgedivisions = dodecadivisions; mp->Magnitude = 2.0; break; case 5: mp->draw_object = draw_icosa; mp->MaterialColor[0] = MaterialRed; mp->MaterialColor[1] = MaterialGreen; mp->MaterialColor[2] = MaterialBlue; mp->MaterialColor[3] = MaterialCyan; mp->MaterialColor[4] = MaterialYellow; mp->MaterialColor[5] = MaterialMagenta; mp->MaterialColor[6] = MaterialRed; mp->MaterialColor[7] = MaterialGreen; mp->MaterialColor[8] = MaterialBlue; mp->MaterialColor[9] = MaterialWhite; mp->MaterialColor[10] = MaterialCyan; mp->MaterialColor[11] = MaterialYellow; mp->MaterialColor[12] = MaterialMagenta; mp->MaterialColor[13] = MaterialRed; mp->MaterialColor[14] = MaterialGreen; mp->MaterialColor[15] = MaterialBlue; mp->MaterialColor[16] = MaterialCyan; mp->MaterialColor[17] = MaterialYellow; mp->MaterialColor[18] = MaterialMagenta; mp->MaterialColor[19] = MaterialGray; mp->edgedivisions = icodivisions; mp->Magnitude = 2.5; break; default: mp->draw_object = draw_tetra; mp->MaterialColor[0] = MaterialRed; mp->MaterialColor[1] = MaterialGreen; mp->MaterialColor[2] = MaterialBlue; mp->MaterialColor[3] = MaterialWhite; mp->edgedivisions = tetradivisions; mp->Magnitude = 2.5; break; } if (MI_IS_MONO(mi)) { int loop; for (loop = 0; loop < 20; loop++) mp->MaterialColor[loop] = MaterialGray; } }
/* some basic initialization of our GL code */ void InitRenderer() { /* glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glShadeModel(GL_SMOOTH); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); */ // starting rotation. g_yRotation = 20.0f; g_xRotation = 30.0f; //initialize the mouse state MouseState.leftButton = MouseState.rightButton = MouseState.middleButton = false; MouseState.x = MouseState.y = 0; // init our eye location eyex = 0; eyey = 0; eyez = 5; focusx = focusy = focusz = 0.0f; glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glMatrixMode(GL_PROJECTION); glLoadIdentity(); // set up our viewing frustum int m_width = glutGet(GLUT_WINDOW_WIDTH); int m_height = glutGet(GLUT_WINDOW_HEIGHT); float aspect = (float)m_width/(float)m_height; gluPerspective(40.0f, aspect, 0.0f, 10000.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //Aggiunto glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_ambient); glLightf( GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0f ); glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.0f ); glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.0f ); glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, material1 ); glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, material2 ); glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, material3 ); glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, material4 ); glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, 10.0f ); // Solid render glPolygonMode( GL_FRONT_AND_BACK , GL_FILL ); //glPolygonMode( GL_FRONT_AND_BACK , GL_LINE ); // Shade mode //glShadeModel(GL_FLAT); glShadeModel(GL_SMOOTH); // Turn on the zbuffer glEnable( GL_DEPTH_TEST ); //glDisable( GL_DEPTH_TEST ); // Turn on zbuffer writing glDepthMask(1); // Turn on zbuffer function glDepthFunc(GL_LESS); // Turn on culling (CCW --> ogl default mode - like d3d) glEnable( GL_CULL_FACE ); glFrontFace( GL_CCW ); }
/** * @param {short} xi_type 0 : RC pilot view * 1 : fly behind view * 2 : upper view * @return helicopter model, ground, sky and shadow on screen drawing **/ void DrawScene(short xi_type) { // statics (scene lighting definitions) static const GLfloat groundAmbient[4] = {0.02f, 0.3f, 0.1f, 1.0f}, local_ambient[4] = {0.7f, 0.7f, 0.7f, 1.0f}, ambient0[4] = {0.0f, 0.0f, 0.0f, 1.0f}, diffuse0[4] = {1.0f, 1.0f, 1.0f, 1.0f}, specular0[4] = {1.0f, 0.0f, 0.0f, 1.0f}, position0[4] = {2.0f, 100.5f, 1.5f, 1.0f}, ambient1[4] = {0.0f, 0.0f, 0.0f, 1.0f}, diffuse1[4] = {1.0f, 1.0f, 1.0f, 1.0f}, specular1[4] = {1.0f, 0.0f, 0.0f, 1.0f}, position1[4] = {-2.0f, 100.5f, 1.0f, 0.0f}; // statics (squashing matrix; 3D -> 2D) static const float mat[16] = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0}; // locals int e; float X, Y, Z; double camera[3], destination[3], up[3]; // view port // scene light definitions glLightModelfv(GL_LIGHT_MODEL_AMBIENT, local_ambient); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient0); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse0); glLightfv(GL_LIGHT0, GL_SPECULAR, specular0); glEnable(GL_LIGHT1); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1); glLightfv(GL_LIGHT1, GL_SPECULAR, specular1); // A/V position X = heli.cg.NED[_NORTH]; // North = X computer frame Y = -heli.cg.NED[_DOWN]; // Down = -Y computer frame Z = heli.cg.NED[_EAST]; // East = Z computer frame // clear view port glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); // view port if (xi_type == 0) { camera[_X] = 1.0; camera[_Y] = 6.0; camera[_Z] = 30.0; destination[_X] = X; destination[_Y] = Y; destination[_Z] = Z; up[_X] = 0.0; up[_Y] = 1.0; up[_Z] = 0.0; } else if (xi_type == 1) { camera[_X] = X - 10 * cos(heli.cg.THETA[_PSI]); camera[_Y] = Y + 1; camera[_Z] = Z - 10 * sin(heli.cg.THETA[_PSI]); destination[_X] = X; destination[_Y] = Y; destination[_Z] = Z; up[_X] = 0.0; up[_Y] = 1.0; up[_Z] = 0.0; } else if (xi_type == 2){ camera[_X] = X; camera[_Y] = 50; camera[_Z] = Z; destination[_X] = X; destination[_Y] = Y; destination[_Z] = Z; up[_X] = 1.0; up[_Y] = 1.0; up[_Z] = 0.0; } gluLookAt(camera[_X], camera[_Y], camera[_Z], destination[_X], destination[_Y], destination[_Z], up[_X], up[_Y], up[_Z]); glEnable(GL_NORMALIZE); glDisable(GL_LIGHTING); // origin heli pad lines glLineWidth(3.0f); glColor3f(0.0f, 0.0f, 1.0f); glBegin(GL_LINES); glVertex3f( 0.0f, 1.0f, 0.0f); glVertex3f( 0.0f, 0.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f); glEnd(); // origin heli pad circle DrawCircle(0.0, 0.0, 1.0, 8); glLineWidth(1.0f); //ground glEnable(GL_LIGHTING); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, groundAmbient); glBegin(GL_POLYGON); glNormal3f(0.0f, 1.0f, 0.0f); glVertex3f(31200.0f, -0.0f, -31200.0f); glVertex3f(-31200.0f, -0.0f, -31200.0f); glVertex3f(-31200.0f, -0.0f, 31200.0f); glVertex3f(31200.0f, -0.0f, 31200.0f); glEnd(); glDisable(GL_LIGHTING); for(e = -1000; e <= 1000; e += 50) { glColor3f(0.0f, 0.0f, 0.0f); glBegin(GL_LINES); glVertex3f(e, 0.8, -1000.0f); glVertex3f(e, 0.8, 1000.0f); glVertex3f(-1000.0f, 0.8, e); glVertex3f(1000.0f, 0.8, e); glEnd(); } glEnable(GL_LIGHTING); glPushMatrix(); glTranslatef(X, Y, Z); glRotatef(heli.cg.THETA[_PSI]*C_RAD2DEG, 0.0f, -1.0f, 0.0); glRotatef(heli.cg.THETA[_THETA]*C_RAD2DEG, 0.0f, 0.0f, 1.0f); glRotatef(heli.cg.THETA[_PHI]*C_RAD2DEG, 1.0f, 0.0f, 0.0f); DrawXcellModel(); glPopMatrix(); /* for (i = 0; i < 6; i++) { glPushMatrix(); glTranslatef(X + pow(-1, i)*i*6, Y + 2*i, Z - i*7); glRotatef(xcell.cg.THETA[_PSI]*C_RAD2DEG + i*50, 0.0f, -1.0f, 0.0); // heading glRotatef(xcell.cg.THETA[_THETA]*C_RAD2DEG - i*3, 0.0f, 0.0f, 1.0f); // pitch glRotatef(xcell.cg.THETA[_PHI]*C_RAD2DEG + i*4, 1.0f, 0.0f, 0.0f); // roll DrawXcellModel(); glPopMatrix(); } */ glPushMatrix(); // Draw the shadows glMultMatrixf(mat); // Everything now is flattened onto the ground glTranslatef(X, 0.01, Z); glRotatef(heli.cg.THETA[_PSI] * C_RAD2DEG, 0.0f, -1.0f, 0.0); glRotatef(heli.cg.THETA[_THETA] * C_RAD2DEG, 0.0f, 0.0f, 1.0f); glRotatef(heli.cg.THETA[_PHI] * C_RAD2DEG, 1.0f, 0.0f, 0.0f); DrawXcellShadowModel(); glPopMatrix(); }
int main(int argc, char *argv[]) { //All must bow for the migthy vector of DOOOOM! vec3 p; eoInitAll(argc, argv, DATADIR); //Enable mouse-selection eoGameEnableMouseSelection(0.2); eoExec("testbox 1"); //Load the cursor sprite_base* dcur_sprb = eoSpriteBaseLoad(Data("/data/gfx/","cursor.spr")); dcur_spr = eoSpriteNew( dcur_sprb, 1, 1 ); sprite_base* hcur_sprb = eoSpriteBaseLoad(Data("/data/gfx/","cursorH.spr")); hcur_spr = eoSpriteNew( hcur_sprb, 1, 1 ); //Setup the 2D gui context ingameContext = eoGuiContextCreate(); winHalp = eoGuiAddWindow(ingameContext, 10, 10, 200, 50, "Halp", NULL); int lblOffset=0, lblInc=13; eoGuiAddLabel(winHalp, 0, 0, "F1 = Console"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "h = Toggle Halp"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "click = Select Obj"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "u,o = obj move y"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "i,j,k,l = obj move x/z"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "8,9= obj rot around y"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "space =free/lock camera"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "del = delete selected object"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "shift = move slower"); lblOffset+=lblInc; eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "Cmds:"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "-------------"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "quit 1"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "addat /dir/file.obj className"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "add /dir/file.obj className"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "rot x y z"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "pos x y z"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "class [newClassName]"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "save FILENAME.lvl"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "merge FILENAME.lvl"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "pinc [num]"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "rinc [num]"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "testbox [0 or 1]"); eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "hitbox [0 or 1]"); winHalp->_size.y +=lblOffset; winObjInfo = eoGuiAddWindow(ingameContext, eoSetting()->res.x- 160, eoSetting()->res.y - 110, 150,100, "Object Info", NULL ); lblInfoClassName = eoGuiAddLabel( winObjInfo, 0,0, "Class: No Object "); lblInfoId = eoGuiAddLabel( winObjInfo, 0,10, "Id: No Object "); lblInfoPos = eoGuiAddLabel( winObjInfo, 0,20, "Pos: No Object "); lblInfoRot = eoGuiAddLabel( winObjInfo, 0,30, "Rot: No Object "); hackyPos.x = 0; hackyPos.y = 2.5; hackyPos.z = 0; eoCamPosSet( hackyPos ); hackyPos.x = 0; hackyPos.y = 0; hackyPos.z = -10; eoCamTargetSet( hackyPos ); eoExec( "camfree 1" ); eoFuncAdd( conLoadObj, NULL, "add"); eoFuncAdd( conLoadObjP, NULL, "addat"); eoFuncAdd( conRotObj, NULL, "rot"); eoFuncAdd( conPosObj, NULL, "pos"); eoFuncAdd( conClassObj, NULL, "class"); eoFuncAdd( conMergeLevel, NULL, "merge"); eoFuncAdd( conSaveLevel, NULL, "save"); eoVarAdd(CON_TYPE_VEC3,0, &hackyPos, "_selectedPos"); eoVarAdd(CON_TYPE_VEC3,0, &hackyRot, "_selectedRot"); eoVarAdd(CON_TYPE_FLOAT,0, &rinc, "rinc"); eoVarAdd(CON_TYPE_FLOAT,0, &pinc, "pinc"); //Set active context eoGuiContextSet(ingameContext); eoGuiWarpMouse( eoSetting()->res.x/2, eoSetting()->res.y/2 ); //Set camera to somewhere p.x=14; p.y=2; p.z=-2.5; eoCamPosSet(p); p.x=-8.52066; p.y=2.107272; p.z=7.96192; //and at something eoCamTargetSet( p ); //Enable 2Dinterface eoGuiShow(); eoGuiShowCursor(1); //Pause simulation eoPauseSet(FALSE); //Register callback function eoRegisterStartFrameFunc( frameStart ); //Set some GL light stuffs GLfloat global_ambient[] = { 0.2f, 0.2f, 0.2f, 2.0f }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient); GLfloat pos[] = { 10,10,10,0 }; //Last pos: 0 = dir, 1=omni glLightfv( GL_LIGHT0, GL_POSITION, pos ); GLfloat specular[] = {0.0, 0.0, 0.0, 1.0}; glLightfv(GL_LIGHT0, GL_SPECULAR, specular); eoInpAddFunc( "exit", "Exit the game.", inpQuitFunc, INPUT_FLAG_DOWN); eoInpAddFunc( "halp", "Toggle the halp window.", inpToggleHalp, INPUT_FLAG_DOWN); eoExec("bind h halp"); eoInpAddFunc( "camtoggle", "Toggle the camfree.", inpToggleCam, INPUT_FLAG_DOWN); eoExec("bind space camtoggle"); eoInpAddFunc( "objMoveUp", "Move currently selected object up along Y.", inpMoveObjUp, INPUT_FLAG_HOLD); eoInpAddFunc( "objMoveDn", "Move currently selected object down along Y.", inpMoveObjDn, INPUT_FLAG_HOLD); eoInpAddFunc( "objMoveLeft", "Move currently selected object down along X.", inpMoveObjLeft, INPUT_FLAG_HOLD); eoInpAddFunc( "objMoveRight", "Move currently selected object up along X.", inpMoveObjRight, INPUT_FLAG_HOLD); eoInpAddFunc( "objMoveForward", "Move currently selected object down along Z.", inpMoveObjForward, INPUT_FLAG_HOLD); eoInpAddFunc( "objMoveBackward", "Move currently selected object up along Z.", inpMoveObjBackward, INPUT_FLAG_HOLD); eoInpAddFunc( "objRotYCW", "Rotate around Y clockwise.", inpRotYPlus, INPUT_FLAG_HOLD); eoInpAddFunc( "objRotYCCW", "Rotate around Y counter-clockwise.", inpRotYMinus, INPUT_FLAG_HOLD); eoInpAddFunc( "objSlow", "Make movement and rotation slow.", inpSlowObj, INPUT_FLAG_UP|INPUT_FLAG_DOWN); eoInpAddFunc( "objRm", "Remove object", inpObjRm, INPUT_FLAG_DOWN); eoExec("bind u objMoveUp"); eoExec("bind o objMoveDn"); eoExec("bind i objMoveForward"); eoExec("bind k objMoveBackward"); eoExec("bind j objMoveLeft"); eoExec("bind l objMoveRight"); eoExec("bind 8 objRotYCW"); eoExec("bind 9 objRotYCCW"); eoExec("bind shiftl objSlow"); eoExec("bind delete objRm"); eoMainLoop(); return 0; }
ENTRYPOINT void init_glblur (ModeInfo *mi) { glblur_configuration *bp; int wire = MI_IS_WIREFRAME(mi); MI_INIT (mi, bps); bp = &bps[MI_SCREEN(mi)]; bp->glx_context = init_GL(mi); reshape_glblur (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ if (!wire) { GLfloat gamb[4]= {0.2, 0.2, 0.2, 1.0}; GLfloat pos[4] = {0.0, 5.0, 10.0, 1.0}; GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0}; GLfloat dif[4] = {0.3, 0.3, 0.3, 1.0}; GLfloat spc[4] = {0.8, 0.8, 0.8, 1.0}; GLfloat shiny = 128; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_NORMALIZE); glShadeModel(GL_SMOOTH); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, gamb); glLightfv(GL_LIGHT0, GL_POSITION, pos); glLightfv(GL_LIGHT0, GL_AMBIENT, amb); glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); glLightfv(GL_LIGHT0, GL_SPECULAR, spc); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glMaterialf(GL_FRONT, GL_SHININESS, shiny); } { Bool spinx=False, spiny=False, spinz=False; double spin_speed = 0.9; double wander_speed = 0.06; char *s = do_spin; while (*s) { if (*s == 'x' || *s == 'X') spinx = True; else if (*s == 'y' || *s == 'Y') spiny = True; else if (*s == 'z' || *s == 'Z') spinz = True; else if (*s == '0') ; else { fprintf (stderr, "%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n", progname, do_spin); exit (1); } s++; } bp->rot = make_rotator (spinx ? spin_speed : 0, spiny ? spin_speed : 0, spinz ? spin_speed : 0, 1.0, do_wander ? wander_speed : 0, False); bp->trackball = gltrackball_init (True); } if (blursize < 0) blursize = 0; if (blursize > 200) blursize = 200; bp->ncolors = 128; bp->colors0 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors1 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors2 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors3 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); make_smooth_colormap (0, 0, 0, bp->colors0, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors1, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors2, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors3, &bp->ncolors, False, 0, False); bp->ccolor = 0; bp->obj_dlist0 = glGenLists (1); bp->obj_dlist1 = glGenLists (1); bp->obj_dlist2 = glGenLists (1); bp->obj_dlist3 = glGenLists (1); bp->scene_dlist1 = glGenLists (1); bp->scene_dlist2 = glGenLists (1); init_texture (mi); generate_object (mi); }
static void pinit(ModeInfo *mi) { /* int status; */ glClearDepth(1.0); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_NORMALIZE); glCullFace(GL_BACK); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialWhite); glShadeModel(GL_FLAT); glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glEnable(GL_CULL_FACE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); #if 0 clear_gl_error(); status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, WoodTextureWidth, WoodTextureHeight, GL_RGB, GL_UNSIGNED_BYTE, WoodTextureData); if (status) { const char *s = (char *) gluErrorString (status); fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n", progname, WoodTextureWidth, WoodTextureHeight, (s ? s : "(unknown)")); exit (1); } check_gl_error("mipmapping"); #else { XImage *img = image_data_to_ximage (mi->dpy, mi->xgwa.visual, wood_png, sizeof(wood_png)); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, img->width, img->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->data); check_gl_error("texture"); XDestroyImage (img); } #endif glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular); }
void GlslApplication::render_scene() const { // backup state so it doesn't mess up students stuff glPushAttrib( GL_ALL_ATTRIB_BITS ); glPushClientAttrib( GL_CLIENT_ALL_ATTRIB_BITS ); // we set most gl state each time since it all gets popped each frame glClearColor( scene.background_color.r, scene.background_color.g, scene.background_color.b, 1.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glEnable( GL_NORMALIZE ); glEnable( GL_DEPTH_TEST ); glEnable( GL_LIGHTING ); glEnable( GL_TEXTURE_2D ); // set camera transform const Camera& camera = camera_control.camera; glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluPerspective( camera.get_fov_degrees(), camera.get_aspect_ratio(), camera.get_near_clip(), camera.get_far_clip() ); const Vector3& campos = camera.get_position(); const Vector3 camref = camera.get_direction() + campos; const Vector3& camup = camera.get_up(); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); gluLookAt( campos.x, campos.y, campos.z, camref.x, camref.y, camref.z, camup.x, camup.y, camup.z ); // set light data float arr[4]; arr[3] = 1.0; // w is always 1 scene.ambient_light.to_array( arr ); glLightModelfv( GL_LIGHT_MODEL_AMBIENT, arr ); glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE ); const Scene::PointLightList& lights = scene.get_lights(); for ( size_t i = 0; i < NUM_GL_LIGHTS && i < lights.size(); i++ ) { const PointLight& light = lights[i]; glEnable( LightConstants[i] ); light.color.to_array( arr ); glLightfv( LightConstants[i], GL_DIFFUSE, arr ); glLightfv( LightConstants[i], GL_SPECULAR, arr ); glLightf( LightConstants[i], GL_CONSTANT_ATTENUATION, light.attenuation.constant ); glLightf( LightConstants[i], GL_LINEAR_ATTENUATION, light.attenuation.linear ); glLightf( LightConstants[i], GL_QUADRATIC_ATTENUATION, light.attenuation.quadratic ); light.position.to_array( arr ); glLightfv( LightConstants[i], GL_POSITION, arr ); } // render each object const Scene::GeometryList& geometries = scene.get_geometries(); for ( size_t i = 0; i < geometries.size(); ++i ) { const Geometry& geom = *geometries[i]; Vector3 axis; real_t angle; glPushMatrix(); glTranslated( geom.position.x, geom.position.y, geom.position.z ); geom.orientation.to_axis_angle( &axis, &angle ); glRotated( angle * ( 180.0 / PI ), axis.x, axis.y, axis.z ); glScaled( geom.scale.x, geom.scale.y, geom.scale.z ); geom.render(); glPopMatrix(); } glPopClientAttrib(); glPopAttrib(); }