// Initialize our rendering device int GLDriver::initialize(IWindow* pWindow) { Assert(pWindow != NULL); Trace("Initializing OpenGL"); glClearColor(0.0f, 0.0f, 0.0f, 0.5f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glClearColor(0.0,0.0,0.0,0.0); glDepthFunc(GL_LEQUAL); glEnable(GL_TEXTURE_2D); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); resize(pWindow->getWidth(), pWindow->getHeight()); //resize /*HWND hwnd; Trace("Initializing OpenGL graphics driver"); hwnd = static_cast< HWND > (pWindow->getWindowHandle()); // Create an OpenGL pixel format descriptor PIXELFORMATDESCRIPTOR pfd = { sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor 1, // Version Number PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, // Format Must Support OpenGL and double buffering PFD_TYPE_RGBA, // Request An RGBA Format pWindow->getBpp(), // Select Our Color Depth 0, 0, 0, 0, 0, 0, // Color Bits Ignored 0, // No Alpha Buffer 0, // Shift Bit Ignored 0, // No Accumulation Buffer 0, 0, 0, 0, // Accumulation Bits Ignored 16, // 16Bit Z-Buffer (Depth Buffer) 0, // No Stencil Buffer 0, // No Auxiliary Buffer PFD_MAIN_PLANE, // Main Drawing Layer 0, // Reserved 0, 0, 0 // Layer Masks Ignored }; // Initialise stuff, and check for errors Trace("Acquiring device context"); if (!(hdc = GetDC(hwnd))) CEngine::CriticalError("Unable to create GL device context!"); Trace("Finding pixel format"); if (!(pixelFormat = ChoosePixelFormat(hdc, &pfd))) CEngine::CriticalError("Unable to find a pixel format!"); Trace("Setting pixel format"); if(!SetPixelFormat(hdc, pixelFormat, &pfd)) CEngine::CriticalError("Unable to set the pixel format!"); Trace("Acquiring rendering context"); if(!(hrc = wglCreateContext(hdc))) CEngine::CriticalError("Unable to create GL rendering context!"); Trace("Setting current GL window"); if(!wglMakeCurrent(hdc, hrc)) CEngine::CriticalError("Unable to activate GL rendering context!"); resize(pWindow->getWidth(), pWindow->getHeight()); // Set up initial gl parameters glClearColor(0.0f, 0.0f, 0.0f, 0.5f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glClearColor(0.0,0.0,0.0,0.0); glDepthFunc(GL_LEQUAL); glEnable(GL_TEXTURE_2D); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); // Grab GL vendor information Trace("Getting OpenGL driver info ..."); char* str; str = (char*)glGetString(GL_VENDOR); vendor.assign(str); Trace("OpenGL Vendor: %s", vendor.c_str()); str = (char*)glGetString(GL_RENDERER); renderer.assign(str); Trace("OpenGL Renderer: %s", renderer.c_str()); str = (char*)glGetString(GL_VERSION); version.assign(str); Trace("OpenGL Version: %s", version.c_str()); str = (char*)glGetString(GL_EXTENSIONS); extensions.assign(str); // Replace all spaces with newlines for(int i = 0; i < extensions.length(); ++i) { if(extensions[i] == ' ') extensions[i] = '\n'; } // Acquire pointer to extension functions // Multitexturing glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB"); glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)wglGetProcAddress("glClientActiveTextureARB"); glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB"); // Set up hardware gamma, if we are using it if(Config::getIntValue("UseHardwareGamma") == 1) { GetDeviceGammaRamp(hdc, &oldGamma); float gamma = 2.0f; for(int i = 0; i < 3; i++) { for(int j = 0;j < 256; j++) { DWORD d = oldGamma[j][i] * gamma; if(d > 65535) d = 65535; newGamma[j][i] = d; } } SetDeviceGammaRamp(hdc, &newGamma); } // Set up the font HFONT oldfont; fontDispListBase = glGenLists(96); font = CreateFont(-17, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH, "Arial"); oldfont = (HFONT)SelectObject(hdc, font); wglUseFontBitmaps(hdc, 32, 96, fontDispListBase); SelectObject(hdc, oldfont); DeleteObject(font); */ return 0; }
//Called to update the display. //You should call glutSwapBuffers after all of your rendering to display what you rendered. //If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function. void display() { glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(g_pConeMesh && g_pCylinderMesh && g_pCubeTintMesh && g_pCubeColorMesh && g_pPlaneMesh) { g_camMatrix.SetMatrix(mainCharacter.AcquireCamera().CalcLookAtMatrix()); glutil::MatrixStack modelMatrix; //Render the ground plane. { glutil::PushStack push(modelMatrix); modelMatrix.ApplyMatrix(g_camMatrix.Top()); modelMatrix.Scale(glm::vec3(100.0f, 1.0f, 100.0f)); glUseProgram(UniformColor.theProgram); glUniformMatrix4fv(UniformColor.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniform4f(UniformColor.baseColorUnif, 0.302f, 0.416f, 0.0589f, 1.0f); g_pPlaneMesh->Render(); glUseProgram(0); } //Draw the trees DrawForest(UniformColorTint, modelMatrix, g_camMatrix); //Draw the building. { glutil::PushStack push(modelMatrix); modelMatrix.ApplyMatrix(g_camMatrix.Top()); modelMatrix.Translate(glm::vec3(20.0f, 0.0f, -10.0f)); DrawParthenon(UniformColorTint, ObjectColor, modelMatrix); } //Draw the treasure for(int i = 0; i < COUNT; i++) { if(littleTreasures[i].IsRemoved() == false) { glutil::PushStack push(modelMatrix); modelMatrix.ApplyMatrix(g_camMatrix.Top()); littleTreasures[i].Update(); littleTreasures[i].Render(UniformColorTint, modelMatrix); } else { littleTreasures[i].Spawn(g_parthenonBaseVolume, g_treeVolumes, ARRAY_COUNT(g_forest), mainCharacter.GetCollisionVolume()); } } } HandleMouse(); glutPostRedisplay(); glutSwapBuffers(); userMouse.OverrideLastPosition(userMouse.GetCurrentPosition()); }
void OrientationOverlay::process() { if (!inport_.isReady()) outport_.activateTarget(); else privatePort_.activateTarget(); //draw the cube in the desired position // set modelview and projection matrices MatStack.matrixMode(tgt::MatrixStack::PROJECTION); MatStack.pushMatrix(); MatStack.loadMatrix(tgt::mat4::createOrtho(-1,1,1,-1,-2,2)); MatStack.matrixMode(tgt::MatrixStack::MODELVIEW); MatStack.pushMatrix(); MatStack.translate(shiftX_.get()*2.0f-1.0f, shiftY_.get()*2.0f-1.0f, 0); tgt::mat4 view = camera_.get().getViewMatrix().getRotationalPart(); MatStack.scale((float)outport_.getSize().y / (float)outport_.getSize().x, 1, 1); MatStack.multMatrix(view); glClearDepth(1); glEnable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); // render cube and axis overlays glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (drawCube_.get() == true) renderCube(); if (drawAxes_.get() == true) renderAxes(); if (!inport_.isReady()) outport_.deactivateTarget(); else privatePort_.deactivateTarget(); // restore OpenGL state glCullFace(GL_BACK); glDisable(GL_CULL_FACE); MatStack.matrixMode(tgt::MatrixStack::PROJECTION); MatStack.popMatrix(); MatStack.matrixMode(tgt::MatrixStack::MODELVIEW); MatStack.popMatrix(); LGL_ERROR; glEnable(GL_DEPTH_TEST); // now do the composition of the OrientationOverlay with the inport render data by shader if (inport_.isReady()) { outport_.activateTarget(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // use the shader to draw cube and axis over inport render data // therefore bind rgba and depth values of both to textures TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1; privatePort_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum()); inport_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum()); // initialize shader program_->activate(); setGlobalShaderParameters(program_); program_->setUniform("colorTexMe_", colorUnit0.getUnitNumber()); program_->setUniform("depthTexMe_", depthUnit0.getUnitNumber()); program_->setUniform("colorTexIn_", colorUnit1.getUnitNumber()); program_->setUniform("depthTexIn_", depthUnit1.getUnitNumber()); privatePort_.setTextureParameters(program_, "textureParametersMe_"); inport_.setTextureParameters(program_, "textureParametersIn_"); glDepthFunc(GL_ALWAYS); renderQuad(); // render quad primitive textured by fragment shader glDepthFunc(GL_LESS); outport_.deactivateTarget(); program_->deactivate(); glActiveTexture(GL_TEXTURE0); } LGL_ERROR; }
void CRenderer::ClearDepth(GLclampf depth) { BEATS_ASSERT(depth >= 0 && depth <= 1); glClearDepth(depth); FC_CHECK_GL_ERROR_DEBUG(); }
GLvoid InitGL(){ //All the stuff we need to draw std::string hero_geo_file = "geo/tank.obj"; std::string target_geo_file = "geo/target.obj"; std::string swivel_geo_file = "geo/turret.obj"; std::string barrel_geo_file = "geo/barrel.obj"; std::string environment_geo_file = "geo/cube.obj"; std::string enemy_geo_file = "geo/enemy.obj"; std::string tile_geo_file = "geo/tile.obj"; std::string tree_geo_file = "geo/tree.obj"; std::string rock_geo_file = "geo/rocks.obj"; std::string hero_tex_file = "tex/tank.ppm"; std::string target_tex_file = "tex/target.ppm"; std::string swivel_tex_file = "tex/turret.ppm"; std::string barrel_tex_file = "tex/barrel.ppm"; std::string environment_tex_file = "tex/cubemape.ppm"; std::string enemy_tex_file = "tex/enemy.ppm"; std::string tile_tex_file = "tex/naked_tile_baked.ppm"; std::string tree_tex_file = "tex/tree.ppm"; std::string rock_tex_file = "tex/rocks.ppm"; std::string tree_tile_tex = "tex/tree_tile.ppm"; std::string rock_tile_tex = "tex/rocky_tile.ppm"; std::string blob_tile_tex = "tex/blob_shadow.ppm"; mesh hero(hero_geo_file); mesh target(target_geo_file); mesh swivel(swivel_geo_file); mesh barrel(barrel_geo_file); mesh environment(environment_geo_file); mesh enemy(enemy_geo_file); mesh tile(tile_geo_file); mesh tree(tree_geo_file); mesh rock(rock_geo_file); HERO_ID = meshes.size(); meshes.push_back(hero); TARGET_ID = meshes.size(); meshes.push_back(target); SWIVEL_ID = meshes.size(); meshes.push_back(swivel); BARREL_ID = meshes.size(); meshes.push_back(barrel); ENVIRONMENT_ID = meshes.size(); meshes.push_back(environment); ENEMY_ID = meshes.size(); meshes.push_back(enemy); TILE_ID = meshes.size(); meshes.push_back(tile); TREE_ID = meshes.size(); meshes.push_back(tree); ROCK_ID = meshes.size(); meshes.push_back(rock); glEnable(GL_TEXTURE_2D); glGenTextures(1, &HERO_TEX); glGenTextures(1, &TARGET_TEX); glGenTextures(1, &SWIVEL_TEX); glGenTextures(1, &BARREL_TEX); glGenTextures(1, &ENVIRONMENT_TEX); glGenTextures(1, &ENEMY_TEX); glGenTextures(1, &TILE_TEX); glGenTextures(1, &TREE_TEX); glGenTextures(1, &ROCK_TEX); glGenTextures(1, &TREETILE_TEX); glGenTextures(1, &ROCKTILE_TEX); glGenTextures(1, &BLOBTILE_TEX); loadPPM(hero_tex_file.c_str(), HERO_TEX); loadPPM(target_tex_file.c_str(), TARGET_TEX); loadPPM(swivel_tex_file.c_str(), SWIVEL_TEX); loadPPM(barrel_tex_file.c_str(), BARREL_TEX); loadPPM(environment_tex_file.c_str(), ENVIRONMENT_TEX); loadPPM(enemy_tex_file.c_str(), ENEMY_TEX); loadPPM(tile_tex_file.c_str(), TILE_TEX); loadPPM(tree_tex_file.c_str(), TREE_TEX); loadPPM(rock_tex_file.c_str(), ROCK_TEX); loadPPM(tree_tile_tex.c_str(), TREETILE_TEX); loadPPM(rock_tile_tex.c_str(), ROCKTILE_TEX); loadPPM(blob_tile_tex.c_str(), BLOBTILE_TEX, true); camera = new game_object(-1,-1,-1); game_object *hero_character = new game_object(characters.size(), HERO_ID, HERO_TEX); characters.push_back(hero_character); game_object *target_character = new game_object(characters.size(), TARGET_ID, TARGET_TEX); target_character->transform.translate(0.0,0.0,-7.0); characters.push_back(target_character); game_object *swivel_character = new game_object(characters.size(), SWIVEL_ID, SWIVEL_TEX); swivel_character->transform.translate(0.0,0.4,0.0); characters.push_back(swivel_character); game_object *barrel_character = new game_object(characters.size(), BARREL_ID, BARREL_TEX); barrel_character->transform.translate(0.0,0.0,-0.15); barrel_character->parent_to(characters[SWIVEL_ID]); characters.push_back(barrel_character); game_object *environment_character = new game_object(characters.size(), ENVIRONMENT_ID, ENVIRONMENT_TEX); environment_character->transform.scale(TILES_DIMENSION,TILES_DIMENSION,TILES_DIMENSION); environment_character->parent_to(camera); characters.push_back(environment_character); // game_object *enemy_character = new game_object(characters.size(), ENEMY_ID, ENEMY_TEX); // enemy_character->transform.translate(0.0, 0.0, -7.0); // enemy_character->parent_to(camera); // characters.push_back(enemy_character); // bad_guys.push_back(ENEMY_ID); srand(time(NULL)); int spread = TILES_DIMENSION; for(int i=1; i<BAD_GUY_COUNT; i++) { game_object *enemyX = new game_object(characters.size(), ENEMY_ID, ENEMY_TEX); enemyX->transform.translate(rand()%spread-spread/2, 0.0, rand()%spread-spread/2); enemyX->transform.rotateY(rand()%180); enemyX->parent_to(camera); bad_guys.push_back(characters.size()); colliders.push_back(characters.size()); characters.push_back(enemyX); } double tile_width = meshes[TILE_ID].xmax - meshes[TILE_ID].xmin; double tile_length = meshes[TILE_ID].zmax - meshes[TILE_ID].zmin; for(int i=0; i<TILES_DIMENSION; i++) { int xmult = i - TILES_DIMENSION/2; for(int j=0; j<TILES_DIMENSION; j++) { int zmult = j - TILES_DIMENSION/2; double rot = rand() % 4 * 90.0; // std::cout << rot << std::endl; game_object *tileX = new game_object(characters.size(), TILE_ID, TILE_TEX); tileX->transform.rotateY(rot); tileX->transform.translate(tile_width*xmult, 0.0, tile_length*zmult); tileX->parent_to(camera); characters.push_back(tileX); int tile_type = rand() % 100; if(tile_type >= 96 && tile_type < 98) { tileX->tex = TREETILE_TEX; game_object *treeX = new game_object(characters.size(), TREE_ID, TREE_TEX); treeX->transform = tileX->transform; treeX->parent_to(camera); bad_guys.push_back(characters.size()); colliders.push_back(characters.size()); characters.push_back(treeX); } else if(tile_type >= 98) { tileX->tex = ROCKTILE_TEX; game_object *rockX = new game_object(characters.size(), ROCK_ID, ROCK_TEX); rockX->transform = tileX->transform; rockX->parent_to(camera); bad_guys.push_back(characters.size()); colliders.push_back(characters.size()); characters.push_back(rockX); } } } game_object *blob_character = new game_object(characters.size(), TILE_ID, BLOBTILE_TEX); blob_character->transform.translate(0.0,0.001,0.0); blob_character->transform.scale(2.0, 1.0, 3.0); characters.push_back(blob_character); last_update = (double)clock() / ((double)CLOCKS_PER_SEC); //GL boilerplate initialization glShadeModel(GL_SMOOTH); // Enable Smooth Shading glClearColor(0.5f, 0.5f, 0.5f, 0.5f); // grey Background glClearDepth(1.0f); // Depth Buffer Setup glEnable(GL_DEPTH_TEST); // Enables Depth Testing glEnable(GL_CULL_FACE); glShadeModel(GL_SMOOTH); glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do glEnable(GL_COLOR_MATERIAL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); }
// // Init GL // int InitGL(GLvoid) // All Setup For OpenGL Goes Here { // seed rand generator srand(getclock()); #if 0 QueryPerformanceFrequency(&timerFrequency); QueryPerformanceCounter(&lastTime); #endif // use the mouse only // for camera movement // disable the cursor ShowCursor(FALSE); Super_LoadGlobals(); Load_ConfigFile(); // Now load main variables Super_LoadBots(); Super_FireAnts(); Create_Col_List(); Create_Wall_List(); // enable all the goodies //glEnable(GL_TEXTURE_2D); // enable texture mapping glShadeModel(GL_SMOOTH); // Enable Smooth Shading glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background glClearDepth(1.0f); // Depth Buffer Setup glEnable(GL_NORMALIZE); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); // Enables Depth Testing glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations // have to load the quadrice to be used quadric=gluNewQuadric(); // Create A Pointer To The Quadric Object (Return 0 If No Memory) (NEW) gluQuadricNormals(quadric, GLU_SMOOTH); // Create Smooth Normals (NEW) gluQuadricTexture(quadric, GL_TRUE); // Create Texture Coords (NEW) #if ENABLE_LIGHTS // InitMaterial(); #endif GenerateBots(); GenerateFireAnts(); // a new breed of warrior CreateWorld(); LoadCameras(); BuildFont(); // Build The Font // Load the objects InitObjects(); GenerateLights(); InitGlobals(); // for printing data, etc // generate the nest objects nest.generate(); garden.generate(); trail_set.generate(); // give the ant food InitFood(); Build_ParticleSet(); Reset_FontID(); // load the title screen text Load_Titles(); // the text library Super_MainText(); CreateWalls(); // // Load the collision test for the wall // very easy test // 4 different walls // // front wall InsertColSegment(world_ptr->x_min, world_ptr->y_max, world_ptr->x_max, world_ptr->y_max); // right wall InsertColSegment(world_ptr->x_max, world_ptr->y_min, world_ptr->x_max, world_ptr->y_max); // back wall (top) InsertColSegment(world_ptr->x_min, world_ptr->y_min, world_ptr->x_max, world_ptr->y_min); // left wall InsertColSegment(world_ptr->x_min, world_ptr->y_min, world_ptr->x_min, world_ptr->y_max); // end insertion -- // // The first thing to do is begin in paused mode // Super_BeginPaused(); mSuper_Loaded = LOADED_TRUE; return TRUE; // Initialization Went OK } // end of the function
//Called to update the display. //You should call glutSwapBuffers after all of your rendering to display what you rendered. //If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function. void display() { glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(g_pConeMesh && g_pCylinderMesh && g_pCubeTintMesh && g_pCubeColorMesh && g_pPlaneMesh) { const glm::vec3 &camPos = ResolveCamPosition(); glutil::MatrixStack camMatrix; camMatrix.SetMatrix(CalcLookAtMatrix(camPos, g_camTarget, glm::vec3(0.0f, 1.0f, 0.0f))); glUseProgram(UniformColor.theProgram); glUniformMatrix4fv(UniformColor.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(camMatrix.Top())); glUseProgram(ObjectColor.theProgram); glUniformMatrix4fv(ObjectColor.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(camMatrix.Top())); glUseProgram(UniformColorTint.theProgram); glUniformMatrix4fv(UniformColorTint.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(camMatrix.Top())); glUseProgram(0); glutil::MatrixStack modelMatrix; //Render the ground plane. { glutil::PushStack push(modelMatrix); modelMatrix.Scale(glm::vec3(100.0f, 1.0f, 100.0f)); glUseProgram(UniformColor.theProgram); glUniformMatrix4fv(UniformColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniform4f(UniformColor.baseColorUnif, 0.302f, 0.416f, 0.0589f, 1.0f); g_pPlaneMesh->Render(); glUseProgram(0); } //Draw the trees DrawForest(modelMatrix); //Draw the building. { glutil::PushStack push(modelMatrix); modelMatrix.Translate(glm::vec3(20.0f, 0.0f, -10.0f)); DrawParthenon(modelMatrix); } if(g_bDrawLookatPoint) { glDisable(GL_DEPTH_TEST); glm::mat4 idenity(1.0f); glutil::PushStack push(modelMatrix); glm::vec3 cameraAimVec = g_camTarget - camPos; modelMatrix.Translate(0.0f, 0.0, -glm::length(cameraAimVec)); modelMatrix.Scale(1.0f, 1.0f, 1.0f); glUseProgram(ObjectColor.theProgram); glUniformMatrix4fv(ObjectColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniformMatrix4fv(ObjectColor.worldToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(idenity)); g_pCubeColorMesh->Render(); glUseProgram(0); glEnable(GL_DEPTH_TEST); } } glutSwapBuffers(); }
void GameEngine::Prerender() { glClearDepth(1.0); // Set depth to 1.0 glClearColor(0.05f, 0.05f, 0.05f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the color and depth buffer }
void COGLGraphicsContext::InitState(void) { m_pRenderStr = glGetString(GL_RENDERER); m_pExtensionStr = glGetString(GL_EXTENSIONS); m_pVersionStr = glGetString(GL_VERSION); m_pVendorStr = glGetString(GL_VENDOR); glMatrixMode(GL_PROJECTION); OPENGL_CHECK_ERRORS; glLoadIdentity(); OPENGL_CHECK_ERRORS; glClearColor(0.0f, 0.0f, 0.0f, 0.0f); OPENGL_CHECK_ERRORS; glClearDepth(1.0f); OPENGL_CHECK_ERRORS; #ifndef USE_GLES glShadeModel(GL_SMOOTH); OPENGL_CHECK_ERRORS; //position viewer //glMatrixMode(GL_MODELVIEW); //glLoadIdentity(); glDisable(GL_ALPHA_TEST); OPENGL_CHECK_ERRORS; #endif glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); OPENGL_CHECK_ERRORS; glDisable(GL_BLEND); OPENGL_CHECK_ERRORS; glFrontFace(GL_CCW); OPENGL_CHECK_ERRORS; glDisable(GL_CULL_FACE); OPENGL_CHECK_ERRORS; #ifndef USE_GLES glDisable(GL_NORMALIZE); OPENGL_CHECK_ERRORS; #endif glDepthFunc(GL_LEQUAL); OPENGL_CHECK_ERRORS; glEnable(GL_DEPTH_TEST); OPENGL_CHECK_ERRORS; #ifndef USE_GLES glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); OPENGL_CHECK_ERRORS; #endif glEnable(GL_BLEND); OPENGL_CHECK_ERRORS; #ifndef USE_GLES glEnable(GL_ALPHA_TEST); OPENGL_CHECK_ERRORS; glMatrixMode(GL_PROJECTION); OPENGL_CHECK_ERRORS; glLoadIdentity(); OPENGL_CHECK_ERRORS; glDepthRange(-1, 1); #else glDepthRangef(0.0f, 1.0f); #endif OPENGL_CHECK_ERRORS; }
GLUSboolean init(GLUSvoid) { GLfloat textureToWorldNormalMatrix[16]; // The maximum detail level which is 2^s = sMapExtend. GLuint sMaxDetailLevel; // The maximum detail level which is 2^t = tMapExtend. GLuint tMaxDetailLevel; // The overall maximum detail level from s and t. GLuint overallMaxDetailLevel; // Step for s and t direction. GLfloat detailStep; GLuint s, t; GLUStgaimage image; GLfloat* map = 0; GLuint* indices = 0; GLUStextfile vertexSource; GLUStextfile controlSource; GLUStextfile evaluationSource; GLUStextfile geometrySource; GLUStextfile fragmentSource; GLfloat lightDirection[3] = { 1.0f, 1.0f, 1.0f }; glusVector3Normalizef(lightDirection); g_topView.cameraPosition[0] = 0.0f; g_topView.cameraPosition[1] = 30000.0f * METERS_TO_VIRTUAL_WORLD_SCALE; g_topView.cameraPosition[2] = 0.0f; g_topView.cameraPosition[3] = 1.0; g_topView.cameraDirection[0] = 0.0f; g_topView.cameraDirection[1] = -1.0f; g_topView.cameraDirection[2] = 0.0f; g_topView.cameraUp[0] = 0.0f; g_topView.cameraUp[1] = 0.0f; g_topView.cameraUp[2] = -1.0f; g_topView.fov = 40.0f; g_personView.cameraPosition[0] = 0.0f; g_personView.cameraPosition[1] = 4700.0f * METERS_TO_VIRTUAL_WORLD_SCALE; g_personView.cameraPosition[2] = 0.0f; g_personView.cameraPosition[3] = 1.0; g_personView.cameraDirection[0] = 0.0f; g_personView.cameraDirection[1] = 0.0f; g_personView.cameraDirection[2] = -1.0f; g_personView.cameraUp[0] = 0.0f; g_personView.cameraUp[1] = 1.0f; g_personView.cameraUp[2] = 0.0f; g_personView.fov = 60.0f; g_activeView = &g_personView; if (!glusLoadTgaImage(NORMAL_MAP, &image)) { printf("Could not load normal picture '%s'!\n", NORMAL_MAP); return GLUS_FALSE; } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &g_normalMapTexture); glBindTexture(GL_TEXTURE_RECTANGLE, g_normalMapTexture); glTexImage2D(GL_TEXTURE_RECTANGLE, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glusDestroyTgaImage(&image); if (!glusLoadTgaImage(HEIGHT_MAP, &image)) { printf("Could not load height picture '%s'!\n", HEIGHT_MAP); return GLUS_FALSE; } glGenTextures(1, &g_heightMapTexture); glBindTexture(GL_TEXTURE_RECTANGLE, g_heightMapTexture); glTexImage2D(GL_TEXTURE_RECTANGLE, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); g_sMapExtend = (GLfloat) image.width; g_tMapExtend = (GLfloat) image.height; glusDestroyTgaImage(&image); // Calculate the detail level for the s and ... sMaxDetailLevel = (GLuint) floorf(logf(g_sMapExtend) / logf(2.0f)); // ... t extend tMaxDetailLevel = (GLuint) floorf(logf(g_tMapExtend) / logf(2.0f)); overallMaxDetailLevel = glusMinf(sMaxDetailLevel, tMaxDetailLevel); // Do checking of calculated parameters if (MINIMUM_DETAIL_LEVEL > overallMaxDetailLevel) { printf("Detail level to high %d > %d\n", MINIMUM_DETAIL_LEVEL, overallMaxDetailLevel); return GLUS_FALSE; } if (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS > overallMaxDetailLevel) { printf("First pass detail level to high %d > %d\n", MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS, overallMaxDetailLevel); return GLUS_FALSE; } if (powf(2.0f, overallMaxDetailLevel - (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS)) > 32.0f) { printf("Tessellation level to high %d > 32\n", (GLint) powf(2.0f, overallMaxDetailLevel - (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS))); return GLUS_FALSE; } detailStep = powf(2.0f, overallMaxDetailLevel - MINIMUM_DETAIL_LEVEL); g_sNumPoints = (GLuint) ceilf(g_sMapExtend / detailStep) - 1; g_tNumPoints = (GLuint) ceilf(g_tMapExtend / detailStep) - 1; // // Generate the flat terrain mesh. // map = (GLUSfloat*) malloc(g_sNumPoints * g_tNumPoints * 2 * sizeof(GLfloat)); indices = (GLuint*) malloc(g_sNumPoints * g_tNumPoints * sizeof(GLuint)); for (t = 0; t < g_tNumPoints; t++) { for (s = 0; s < g_sNumPoints; s++) { map[t * g_sNumPoints * 2 + s * 2 + 0] = 0.5f + detailStep / 2.0f + (GLfloat) s * detailStep; map[t * g_sNumPoints * 2 + s * 2 + 1] = 0.5f + detailStep / 2.0f + (GLfloat) t * detailStep; indices[t * g_sNumPoints + s + 0] = (t + 0) * g_sNumPoints + s + 0; } } // // Transferring vertices and indices into GPU // // Pass one glGenBuffers(1, &g_verticesPassOneVBO); glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassOneVBO); glBufferData(GL_ARRAY_BUFFER, g_sNumPoints * g_tNumPoints * 2 * sizeof(GLfloat), map, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &g_indicesPassOneVBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPassOneVBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, g_sNumPoints * g_tNumPoints * sizeof(GLuint), indices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // Pass two. glGenBuffers(1, &g_verticesPassTwoVBO); glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassTwoVBO); // Calculate enough space! glBufferData(GL_ARRAY_BUFFER, g_sNumPoints * g_tNumPoints * (GLuint) pow(4, DETAIL_LEVEL_FIRST_PASS + 1) * 2 * sizeof(GLfloat), 0, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); // free(map); map = 0; free(indices); indices = 0; // if (!glusLoadTgaImage(COLOR_MAP, &image)) { printf("Could not load color picture '%s'!\n", COLOR_MAP); return GLUS_FALSE; } glGenTextures(1, &g_colorMapTexture); glBindTexture(GL_TEXTURE_2D, g_colorMapTexture); glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glusDestroyTgaImage(&image); // glGenQueries(1, &g_transformFeedbackQuery); // // Creating the shader program. // // Pass one. glusLoadTextFile("../Example14/shader/PassOne.vert.glsl", &vertexSource); glusLoadTextFile("../Example14/shader/PassOne.geom.glsl", &geometrySource); glusLoadTextFile("../Example14/shader/PassOne.frag.glsl", &fragmentSource); // Compile and ... glusCreateProgramFromSource(&g_programPassOne, (const GLUSchar**) &vertexSource.text, 0, 0, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text); // ... add the transform variable ... glTransformFeedbackVaryings(g_programPassOne.program, 1, (const GLchar**) &TRANSFORM_VARYING, GL_SEPARATE_ATTRIBS); // ... and link the program if (!glusLinkProgram(&g_programPassOne)) { printf("Could not build program one\n"); return GLUS_FALSE; } // Destroy the text resource glusDestroyTextFile(&vertexSource); glusDestroyTextFile(&geometrySource); glusDestroyTextFile(&fragmentSource); g_halfDetailStepPassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_halfDetailStep"); g_detailLevelPassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_detailLevel"); g_fovRadiusPassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_fovRadius"); g_positionTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_positionTextureSpace"); g_leftNormalTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_leftNormalTextureSpace"); g_rightNormalTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_rightNormalTextureSpace"); g_backNormalTextureSpacePassOneLocation = glGetUniformLocation(g_programPassOne.program, "u_backNormalTextureSpace"); // Pass two. glusLoadTextFile("../Example14/shader/PassTwo.vert.glsl", &vertexSource); glusLoadTextFile("../Example14/shader/PassTwo.cont.glsl", &controlSource); glusLoadTextFile("../Example14/shader/PassTwo.eval.glsl", &evaluationSource); glusLoadTextFile("../Example14/shader/PassTwo.geom.glsl", &geometrySource); glusLoadTextFile("../Example14/shader/PassTwo.frag.glsl", &fragmentSource); if (!glusBuildProgramFromSource(&g_shaderProgramPassTwo, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &controlSource.text, (const GLUSchar**) &evaluationSource.text, (const GLUSchar**) &geometrySource.text, (const GLUSchar**) &fragmentSource.text)) { printf("Could not build program two\n"); return GLUS_FALSE; } glusDestroyTextFile(&vertexSource); glusDestroyTextFile(&controlSource); glusDestroyTextFile(&evaluationSource); glusDestroyTextFile(&geometrySource); glusDestroyTextFile(&fragmentSource); g_maxTessellationLevelPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_maxTessellationLevel"); g_quadrantStepPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_quadrantStep"); g_positionTextureSpacePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_positionTextureSpace"); g_heightMapTexturePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_heightMapTexture"); g_normalMapTexturePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_normalMapTexture"); g_tmvpPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_tmvpMatrix"); g_lightDirectionPassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_lightDirection"); g_colorMapTexturePassTwoLocation = glGetUniformLocation(g_shaderProgramPassTwo.program, "u_colorMapTexture"); // // One time matrix calculations to convert between texture and world space glusMatrix4x4Identityf(g_textureToWorldMatrix); glusMatrix4x4Identityf(textureToWorldNormalMatrix); glusMatrix4x4Scalef(g_textureToWorldMatrix, HORIZONTAL_PIXEL_SPACING * METERS_TO_VIRTUAL_WORLD_SCALE, VERTICAL_PIXEL_RANGE * METERS_TO_VIRTUAL_WORLD_SCALE, HORIZONTAL_PIXEL_SPACING * METERS_TO_VIRTUAL_WORLD_SCALE); // Skip this scale for the normal matrix glusMatrix4x4Scalef(g_textureToWorldMatrix, 1.0f, 1.0f, -1.0f); glusMatrix4x4Scalef(textureToWorldNormalMatrix, 1.0f, 1.0f, -1.0f); glusMatrix4x4Translatef(g_textureToWorldMatrix, -g_sMapExtend / 2.0f, 0.0f, -g_tMapExtend / 2.0f); // No need for the translation matrix in the normal matrix glusMatrix4x4Copyf(g_worldToTextureMatrix, g_textureToWorldMatrix, GLUS_FALSE); glusMatrix4x4Inversef(g_worldToTextureMatrix); glusMatrix4x4Copyf(g_worldToTextureNormalMatrix, textureToWorldNormalMatrix, GLUS_FALSE); glusMatrix4x4Inversef(g_worldToTextureNormalMatrix); // Pass one glUseProgram(g_programPassOne.program); glUniform1f(g_halfDetailStepPassOneLocation, detailStep / 2.0f); glUniform1ui(g_detailLevelPassOneLocation, DETAIL_LEVEL_FIRST_PASS); glUniform1f(g_fovRadiusPassOneLocation, FOV_RADIUS / HORIZONTAL_PIXEL_SPACING * METERS_TO_VIRTUAL_WORLD_SCALE); glGenVertexArrays(1, &g_vaoPassOne); glBindVertexArray(g_vaoPassOne); glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassOneVBO); // First 0 is the location = 0. See shader source glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0); // Enable location = 0 glEnableVertexAttribArray(0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesPassOneVBO); // Pass two glUseProgram(g_shaderProgramPassTwo.program); glUniform3fv(g_lightDirectionPassTwoLocation, 1, lightDirection); glUniform1ui(g_maxTessellationLevelPassTwoLocation, overallMaxDetailLevel - (MINIMUM_DETAIL_LEVEL + DETAIL_LEVEL_FIRST_PASS)); glUniform1i(g_quadrantStepPassTwoLocation, QUADRANT_STEP); glGenVertexArrays(1, &g_vaoPassTwo); glBindVertexArray(g_vaoPassTwo); glBindBuffer(GL_ARRAY_BUFFER, g_verticesPassTwoVBO); // First 0 is the location = 0. See shader source glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0); // Enable location = 0 glEnableVertexAttribArray(0); // glActiveTexture(GL_TEXTURE0); glUniform1i(g_heightMapTexturePassTwoLocation, 0); glBindTexture(GL_TEXTURE_RECTANGLE, g_heightMapTexture); glActiveTexture(GL_TEXTURE1); glUniform1i(g_colorMapTexturePassTwoLocation, 1); glBindTexture(GL_TEXTURE_2D, g_colorMapTexture); glActiveTexture(GL_TEXTURE2); glUniform1i(g_normalMapTexturePassTwoLocation, 2); glBindTexture(GL_TEXTURE_RECTANGLE, g_normalMapTexture); // glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glPatchParameteri(GL_PATCH_VERTICES, 4); return GLUS_TRUE; }
bool glWindow::ResetGL () { if (m_resetGLMode == RGM_RECREATEWINDOW) { RecreateWindow (m_fullScreen, m_border, m_width, m_height, m_bpp, m_stencil, m_title, m_allowResizing, m_fitToWorkArea); return true; } else if (m_resetGLMode == RGM_RECREATECONTEXT) { RecreateGLContext (); return true; } // Setup OpenGL defaults. // This should reset as much as possible back to the initial state of OpenGL. // Exceptions: // * Projection matrix is initialised to a perspective transform // End current gl block try { glEnd (); } catch (...) { ; } m_dontPaint = false; // Intialise matrices try { glMatrixMode (GL_PROJECTION); ClearGLMatrix (); } catch (...) { ; } try { glMatrixMode (GL_TEXTURE); ClearGLMatrix (); } catch (...) { ; } try { glMatrixMode (GL_MODELVIEW); ClearGLMatrix (); } catch (...) { ; } // Initialise state int i; try { glColor4f (1, 1, 1, 1); } catch (...) { ; } try { glIndexi (1); } catch (...) { ; } try { glTexCoord4f (0, 0, 0, 1); } catch (...) { ; } try { glNormal3f (0, 0, 1); } catch (...) { ; } // try { glRasterPos4f (0, 0, 0, 1); } catch (...) { ; } try { glEdgeFlag (GL_TRUE); } catch (...) { ; } try { glDisable (GL_VERTEX_ARRAY); } catch (...) { ; } try { glDisable (GL_NORMAL_ARRAY); } catch (...) { ; } try { glDisable (GL_COLOR_ARRAY); } catch (...) { ; } try { glDisable (GL_INDEX_ARRAY); } catch (...) { ; } try { glDisable (GL_TEXTURE_COORD_ARRAY); } catch (...) { ; } try { glDisable (GL_EDGE_FLAG_ARRAY); } catch (...) { ; } try { glDepthRange (0, 1); } catch (...) { ; } try { glDisable (GL_NORMALIZE); } catch (...) { ; } for (i = 0; i < GL_MAX_CLIP_PLANES; i++) try { glDisable (GL_CLIP_PLANE0 + i); } catch (...) { ; } GLfloat fog[] = {0, 0, 0, 0}; try { glFogfv (GL_FOG_COLOR, fog); } catch (...) { ; } try { glFogi (GL_FOG_INDEX, 0); } catch (...) { ; } try { glFogf (GL_FOG_DENSITY, 1.0); } catch (...) { ; } try { glFogf (GL_FOG_START, 0.0); } catch (...) { ; } try { glFogf (GL_FOG_END, 1.0); } catch (...) { ; } try { glFogi (GL_FOG_MODE, GL_EXP); } catch (...) { ; } try { glDisable (GL_FOG); } catch (...) { ; } try { glShadeModel (GL_SMOOTH); } catch (...) { ; } try { glDisable (GL_LIGHTING); } catch (...) { ; } try { glDisable (GL_COLOR_MATERIAL); } catch (...) { ; } try { glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); } catch (...) { ; } GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 }, diffuse[] = { 0.8, 0.8, 0.8, 1.0 }, specular[] = { 0.0, 0.0, 0.0, 1.0 }, emission[] = { 0.0, 0.0, 0.0, 1.0 }, shininess[] = { 0.0 }; try { glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, ambient); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); } catch (...) { ; } try { glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, shininess); } catch (...) { ; } try { glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambient); } catch (...) { ; } try { glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); } catch (...) { ; } try { glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); } catch (...) { ; } GLfloat lambient[] = { 0.0, 0.0, 0.0, 1.0 }, ldiffuse0[] = { 1.0, 1.0, 1.0, 1.0 }, ldiffuse1[] = { 0.0, 0.0, 0.0, 1.0 }, lspecular0[] = { 1.0, 1.0, 1.0, 1.0 }, lspecular1[] = { 0.0, 0.0, 0.0, 1.0 }, lposition[] = { 0.0, 0.0, 1.0, 0.0 }; for (i = 0; i < 8; i++) { try { glLightfv (GL_LIGHT0 + i, GL_AMBIENT, lambient); } catch (...) { ; } try { glLightfv (GL_LIGHT0 + i, GL_DIFFUSE, i == 0 ? ldiffuse0 : ldiffuse1); } catch (...) { ; } try { glLightfv (GL_LIGHT0 + i, GL_SPECULAR, i == 0 ? lspecular0 : lspecular1); } catch (...) { ; } try { glLightfv (GL_LIGHT0 + i, GL_POSITION, lposition); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_SPOT_EXPONENT, 0.0); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, 1.0); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, 0.0); } catch (...) { ; } try { glLightf (GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, 0.0); } catch (...) { ; } try { glDisable (GL_LIGHT0 + i); } catch (...) { ; } } try { glPointSize (1.0); } catch (...) { ; } try { glDisable (GL_POINT_SMOOTH); } catch (...) { ; } try { glLineWidth (1.0); } catch (...) { ; } try { glDisable (GL_LINE_SMOOTH); } catch (...) { ; } try { glLineStipple (1, 0xffff); } catch (...) { ; } try { glDisable (GL_LINE_STIPPLE); } catch (...) { ; } try { glDisable (GL_CULL_FACE); } catch (...) { ; } try { glCullFace (GL_BACK); } catch (...) { ; } try { glFrontFace (GL_CCW); } catch (...) { ; } try { glDisable (GL_POLYGON_SMOOTH); } catch (...) { ; } try { glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); } catch (...) { ; } try { glDisable (GL_TEXTURE_1D); } catch (...) { ; } try { glDisable (GL_TEXTURE_2D); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); } catch (...) { ; } try { glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } catch (...) { ; } GLfloat texBorder[] = {0, 0, 0, 0}; try { glTexParameterfv (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, texBorder); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_T); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_S); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_R); } catch (...) { ; } try { glDisable (GL_TEXTURE_GEN_Q); } catch (...) { ; } for (i = 0; i < 4; i++) { GLenum coord; switch (i) { case 0: coord = GL_T; break; case 1: coord = GL_S; break; case 2: coord = GL_R; break; case 3: coord = GL_Q; break; } try { glTexGeni (coord, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); } catch (...) { ; } } try { glDisable (GL_SCISSOR_TEST); } catch (...) { ; } try { glDisable (GL_ALPHA_TEST); } catch (...) { ; } try { glAlphaFunc (GL_ALWAYS, 0); } catch (...) { ; } try { glDisable (GL_STENCIL_TEST); } catch (...) { ; } try { glStencilFunc (GL_ALWAYS, 0, 0xffffffff); } catch (...) { ; } try { glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); } catch (...) { ; } try { glDisable (GL_DEPTH_TEST); } catch (...) { ; } try { glDepthFunc (GL_LESS); } catch (...) { ; } try { glDisable (GL_BLEND); } catch (...) { ; } try { glBlendFunc (GL_ONE, GL_ZERO); } catch (...) { ; } try { glDrawBuffer (GL_BACK); } catch (...) { ; } try { glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } catch (...) { ; } try { glDepthMask (GL_TRUE); } catch (...) { ; } try { glClearAccum (0, 0, 0, 0); } catch (...) { ; } try { glClearColor (0, 0, 0, 0); } catch (...) { ; } try { glClearDepth (1); } catch (...) { ; } try { glClearIndex (0); } catch (...) { ; } try { glClearStencil (0); } catch (...) { ; } try { glPixelStorei (GL_PACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; } try { glPixelStorei (GL_PACK_LSB_FIRST, GL_FALSE); } catch (...) { ; } try { glPixelStoref (GL_PACK_ROW_LENGTH, 0); } catch (...) { ; } try { glPixelStoref (GL_PACK_SKIP_PIXELS, 0); } catch (...) { ; } try { glPixelStorei (GL_PACK_ALIGNMENT, 4); } catch (...) { ; } try { glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE); } catch (...) { ; } try { glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE); } catch (...) { ; } try { glPixelStoref (GL_UNPACK_ROW_LENGTH, 0); } catch (...) { ; } try { glPixelStoref (GL_UNPACK_SKIP_PIXELS, 0); } catch (...) { ; } try { glPixelStorei (GL_UNPACK_ALIGNMENT, 4); } catch (...) { ; } try { glPixelTransferi (GL_MAP_COLOR, GL_FALSE); } catch (...) { ; } try { glPixelTransferi (GL_MAP_STENCIL, GL_FALSE); } catch (...) { ; } try { glPixelTransferi (GL_INDEX_SHIFT, 0); } catch (...) { ; } try { glPixelTransferi (GL_INDEX_OFFSET, 0); } catch (...) { ; } try { glPixelTransferf (GL_RED_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_GREEN_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_BLUE_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_ALPHA_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_DEPTH_SCALE, 1.0); } catch (...) { ; } try { glPixelTransferf (GL_RED_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_GREEN_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_BLUE_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_ALPHA_BIAS, 0.0); } catch (...) { ; } try { glPixelTransferf (GL_DEPTH_BIAS, 0.0); } catch (...) { ; } try { glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_POINT_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); } catch (...) { ; } try { glHint (GL_FOG_HINT, GL_DONT_CARE); } catch (...) { ; } // Multitexturing if (ExtensionSupported ("GL_ARB_multitexture")) { // Disable texturing for all texture units int units; try { glGetIntegerv (GL_MAX_TEXTURE_UNITS_ARB, &units); } catch (...) { ; } for (int i = 0; i < units; i++) { if (glActiveTexture != NULL) glActiveTexture (GL_TEXTURE0_ARB + i); try { glDisable (GL_TEXTURE_2D); } catch (...) { ; } try { glDisable (GL_TEXTURE_1D); } catch (...) { ; } if (i == 0) try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } catch (...) { ; } else try { glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } catch (...) { ; } } if (glActiveTexture != NULL) try { glActiveTexture (GL_TEXTURE0_ARB); } catch (...) { ; } } // Setup OpenGL defaults OpenGLDefaults (); return TRUE; // Initialization Went OK }
//OpenGL Loop Logic void glLoop() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /*gModelMat = glm::rotate(gModelMat, -0.01f, glm::vec3(0.f, 0.f, 1.f)); glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(gModelMat));*/ glUseProgram(gShadowProg); glBindVertexArray(gShadowVao); glBindFramebuffer(GL_FRAMEBUFFER, gShadowFbo); glViewport(0, 0, SHADOW_DEPTH_TEXTURE_SIZE, SHADOW_DEPTH_TEXTURE_SIZE); glClearDepth(1.0f); glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(2.f, 4.f); for (auto& e: gSceneGraph) { glUniformMatrix4fv(gShadowModelMatLoc, 1, GL_FALSE, glm::value_ptr(e.modelMat)); glBindBuffer(GL_ARRAY_BUFFER, e.glPosBuf); glVertexAttribPointer(gShadowPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); glDrawArrays(GL_TRIANGLES, 0, e.vertCount); } glDisable(GL_POLYGON_OFFSET_FILL); glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(0, 0, WIN_WIDTH * 2, WIN_HEIGHT * 2); glUseProgram(gRenderProg); glBindVertexArray(gVao); for (auto& e: gSceneGraph) { glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(e.modelMat)); glUniform3fv(gAmbientLoc, 1, glm::value_ptr(e.ambientColor)); glUniform3fv(gDiffuseLoc, 1, glm::value_ptr(e.diffuseColor)); glUniform3fv(gSpecularLoc, 1, glm::value_ptr(e.specularColor)); glUniform1f(gShininessLoc, e.shininess); glUniform1f(gSpecStrengthLoc, e.specStrength); glUniform1i(gIsTexturedLoc, e.isTextured); glUniform1i(gTexUnitLoc, e.glTexUnit); glUniform4fv(gColorLoc, 1, glm::value_ptr(e.objColor)); glBindBuffer(GL_ARRAY_BUFFER, e.glPosBuf); glVertexAttribPointer(gPosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); glBindBuffer(GL_ARRAY_BUFFER, e.glTexCoordBuf); glVertexAttribPointer(gTexCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL); glBindBuffer(GL_ARRAY_BUFFER, e.glNormBuf); glVertexAttribPointer(gNormLoc, 3, GL_FLOAT, GL_FALSE, 0, NULL); glDrawArrays(GL_TRIANGLES, 0, e.vertCount); } /*glUseProgram(gTextureProg); glBindVertexArray(gTextureVao); glDrawArrays(GL_TRIANGLES, 0, 6);*/ }
void GraphicsWindow::Paint(void) { int i; havePainted = true; int w, h; GetGraphicsWindowSize(&w, &h); width = w; height = h; glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glScaled(scale*2.0/w, scale*2.0/h, scale*1.0/30000); double mat[16]; // Last thing before display is to apply the perspective double clp = SS.CameraTangent()*scale; MakeMatrix(mat, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, clp, 1); glMultMatrixd(mat); // Before that, we apply the rotation Vector n = projUp.Cross(projRight); MakeMatrix(mat, projRight.x, projRight.y, projRight.z, 0, projUp.x, projUp.y, projUp.z, 0, n.x, n.y, n.z, 0, 0, 0, 0, 1); glMultMatrixd(mat); // And before that, the translation MakeMatrix(mat, 1, 0, 0, offset.x, 0, 1, 0, offset.y, 0, 0, 1, offset.z, 0, 0, 0, 1); glMultMatrixd(mat); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glShadeModel(GL_SMOOTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); // don't enable GL_POLYGON_SMOOTH; that looks ugly on some graphics cards, // drawn with leaks in the mesh glEnable(GL_POLYGON_OFFSET_LINE); glEnable(GL_POLYGON_OFFSET_FILL); glEnable(GL_DEPTH_TEST); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glEnable(GL_NORMALIZE); // At the same depth, we want later lines drawn over earlier. glDepthFunc(GL_LEQUAL); if(SS.AllGroupsOkay()) { glClearColor(REDf(SS.backgroundColor), GREENf(SS.backgroundColor), BLUEf(SS.backgroundColor), 1.0f); } else { // Draw a different background whenever we're having solve problems. DWORD rgb = Style::Color(Style::DRAW_ERROR); glClearColor(0.4f*REDf(rgb), 0.4f*GREENf(rgb), 0.4f*BLUEf(rgb), 1.0f); // And show the text window, which has info to debug it ForceTextWindowShown(); } glClear(GL_COLOR_BUFFER_BIT); glClearDepth(1.0); glClear(GL_DEPTH_BUFFER_BIT); if(SS.bgImage.fromFile) { // If a background image is loaded, then we draw it now as a texture. // This handles the resizing for us nicely. glBindTexture(GL_TEXTURE_2D, TEXTURE_BACKGROUND_IMG); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, SS.bgImage.rw, SS.bgImage.rh, 0, GL_RGB, GL_UNSIGNED_BYTE, SS.bgImage.fromFile); double tw = ((double)SS.bgImage.w) / SS.bgImage.rw, th = ((double)SS.bgImage.h) / SS.bgImage.rh; double mmw = SS.bgImage.w / SS.bgImage.scale, mmh = SS.bgImage.h / SS.bgImage.scale; Vector origin = SS.bgImage.origin; origin = origin.DotInToCsys(projRight, projUp, n); // Place the depth of our origin at the point that corresponds to // w = 1, so that it's unaffected by perspective. origin.z = (offset.ScaledBy(-1)).Dot(n); origin = origin.ScaleOutOfCsys(projRight, projUp, n); // Place the background at the very back of the Z order, though, by // mucking with the depth range. glDepthRange(1, 1); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glTexCoord2d(0, 0); glxVertex3v(origin); glTexCoord2d(0, th); glxVertex3v(origin.Plus(projUp.ScaledBy(mmh))); glTexCoord2d(tw, th); glxVertex3v(origin.Plus(projRight.ScaledBy(mmw).Plus( projUp. ScaledBy(mmh)))); glTexCoord2d(tw, 0); glxVertex3v(origin.Plus(projRight.ScaledBy(mmw))); glEnd(); glDisable(GL_TEXTURE_2D); } glxDepthRangeOffset(0); // Nasty case when we're reloading the imported files; could be that // we get an error, so a dialog pops up, and a message loop starts, and // we have to get called to paint ourselves. If the sketch is screwed // up, then we could trigger an oops trying to draw. if(!SS.allConsistent) return; // Let's use two lights, at the user-specified locations GLfloat f; glEnable(GL_LIGHT0); f = (GLfloat)SS.lightIntensity[0]; GLfloat li0[] = { f, f, f, 1.0f }; glLightfv(GL_LIGHT0, GL_DIFFUSE, li0); glLightfv(GL_LIGHT0, GL_SPECULAR, li0); glEnable(GL_LIGHT1); f = (GLfloat)SS.lightIntensity[1]; GLfloat li1[] = { f, f, f, 1.0f }; glLightfv(GL_LIGHT1, GL_DIFFUSE, li1); glLightfv(GL_LIGHT1, GL_SPECULAR, li1); Vector ld; ld = VectorFromProjs(SS.lightDir[0]); GLfloat ld0[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 }; glLightfv(GL_LIGHT0, GL_POSITION, ld0); ld = VectorFromProjs(SS.lightDir[1]); GLfloat ld1[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 }; glLightfv(GL_LIGHT1, GL_POSITION, ld1); if(SS.drawBackFaces) { // For debugging, draw the backs of the triangles in red, so that we // notice when a shell is open glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1); } else { glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 0); } GLfloat ambient[4] = { (float)SS.ambientIntensity, (float)SS.ambientIntensity, (float)SS.ambientIntensity, 1 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glxUnlockColor(); if(showSnapGrid && LockedInWorkplane()) { hEntity he = ActiveWorkplane(); EntityBase *wrkpl = SK.GetEntity(he), *norm = wrkpl->Normal(); Vector wu, wv, wn, wp; wp = SK.GetEntity(wrkpl->point[0])->PointGetNum(); wu = norm->NormalU(); wv = norm->NormalV(); wn = norm->NormalN(); double g = SS.gridSpacing; double umin = VERY_POSITIVE, umax = VERY_NEGATIVE, vmin = VERY_POSITIVE, vmax = VERY_NEGATIVE; int a; for(a = 0; a < 4; a++) { // Ideally, we would just do +/- half the width and height; but // allow some extra slop for rounding. Vector horiz = projRight.ScaledBy((0.6*width)/scale + 2*g), vert = projUp. ScaledBy((0.6*height)/scale + 2*g); if(a == 2 || a == 3) horiz = horiz.ScaledBy(-1); if(a == 1 || a == 3) vert = vert. ScaledBy(-1); Vector tp = horiz.Plus(vert).Minus(offset); // Project the point into our grid plane, normal to the screen // (not to the grid plane). If the plane is on edge then this is // impossible so don't try to draw the grid. bool parallel; Vector tpp = Vector::AtIntersectionOfPlaneAndLine( wn, wn.Dot(wp), tp, tp.Plus(n), ¶llel); if(parallel) goto nogrid; tpp = tpp.Minus(wp); double uu = tpp.Dot(wu), vv = tpp.Dot(wv); umin = min(uu, umin); umax = max(uu, umax); vmin = min(vv, vmin); vmax = max(vv, vmax); } int i, j, i0, i1, j0, j1; i0 = (int)(umin / g); i1 = (int)(umax / g); j0 = (int)(vmin / g); j1 = (int)(vmax / g); if(i0 > i1 || i1 - i0 > 400) goto nogrid; if(j0 > j1 || j1 - j0 > 400) goto nogrid; glLineWidth(1); glxColorRGBa(Style::Color(Style::DATUM), 0.3); glBegin(GL_LINES); for(i = i0 + 1; i < i1; i++) { glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j0*g))); glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j1*g))); } for(j = j0 + 1; j < j1; j++) { glxVertex3v(wp.Plus(wu.ScaledBy(i0*g)).Plus(wv.ScaledBy(j*g))); glxVertex3v(wp.Plus(wu.ScaledBy(i1*g)).Plus(wv.ScaledBy(j*g))); } glEnd(); // Clear the depth buffer, so that the grid is at the very back of // the Z order. glClear(GL_DEPTH_BUFFER_BIT); nogrid:; } // Draw the active group; this does stuff like the mesh and edges. (SK.GetGroup(activeGroup))->Draw(); // Now draw the entities if(showHdnLines) glDisable(GL_DEPTH_TEST); Entity::DrawAll(); // Draw filled paths in all groups, when those filled paths were requested // specially by assigning a style with a fill color, or when the filled // paths are just being filled by default. This should go last, to make // the transparency work. Group *g; for(g = SK.group.First(); g; g = SK.group.NextAfter(g)) { if(!(g->IsVisible())) continue; g->DrawFilledPaths(); } glDisable(GL_DEPTH_TEST); // Draw the constraints for(i = 0; i < SK.constraint.n; i++) { SK.constraint.elem[i].Draw(); } // Draw the traced path, if one exists glLineWidth(Style::Width(Style::ANALYZE)); glxColorRGB(Style::Color(Style::ANALYZE)); SContour *sc = &(SS.traced.path); glBegin(GL_LINE_STRIP); for(i = 0; i < sc->l.n; i++) { glxVertex3v(sc->l.elem[i].p); } glEnd(); // And the naked edges, if the user did Analyze -> Show Naked Edges. glLineWidth(Style::Width(Style::DRAW_ERROR)); glxColorRGB(Style::Color(Style::DRAW_ERROR)); glxDrawEdges(&(SS.nakedEdges), true); // Then redraw whatever the mouse is hovering over, highlighted. glDisable(GL_DEPTH_TEST); glxLockColorTo(Style::Color(Style::HOVERED)); hover.Draw(); // And finally draw the selection, same mechanism. glxLockColorTo(Style::Color(Style::SELECTED)); for(Selection *s = selection.First(); s; s = selection.NextAfter(s)) { s->Draw(); } glxUnlockColor(); // If a marquee selection is in progress, then draw the selection // rectangle, as an outline and a transparent fill. if(pending.operation == DRAGGING_MARQUEE) { Point2d begin = ProjectPoint(orig.marqueePoint); double xmin = min(orig.mouse.x, begin.x), xmax = max(orig.mouse.x, begin.x), ymin = min(orig.mouse.y, begin.y), ymax = max(orig.mouse.y, begin.y); Vector tl = UnProjectPoint(Point2d::From(xmin, ymin)), tr = UnProjectPoint(Point2d::From(xmax, ymin)), br = UnProjectPoint(Point2d::From(xmax, ymax)), bl = UnProjectPoint(Point2d::From(xmin, ymax)); glLineWidth((GLfloat)1.3); glxColorRGB(Style::Color(Style::HOVERED)); glBegin(GL_LINE_LOOP); glxVertex3v(tl); glxVertex3v(tr); glxVertex3v(br); glxVertex3v(bl); glEnd(); glxColorRGBa(Style::Color(Style::HOVERED), 0.10); glBegin(GL_QUADS); glxVertex3v(tl); glxVertex3v(tr); glxVertex3v(br); glxVertex3v(bl); glEnd(); } // An extra line, used to indicate the origin when rotating within the // plane of the monitor. if(SS.extraLine.draw) { glLineWidth(1); glxLockColorTo(Style::Color(Style::DATUM)); glBegin(GL_LINES); glxVertex3v(SS.extraLine.ptA); glxVertex3v(SS.extraLine.ptB); glEnd(); } // A note to indicate the origin in the just-exported file. if(SS.justExportedInfo.draw) { glxColorRGB(Style::Color(Style::DATUM)); Vector p = SS.justExportedInfo.pt, u = SS.justExportedInfo.u, v = SS.justExportedInfo.v; glLineWidth(1.5); glBegin(GL_LINES); glxVertex3v(p.Plus(u.WithMagnitude(-15/scale))); glxVertex3v(p.Plus(u.WithMagnitude(30/scale))); glxVertex3v(p.Plus(v.WithMagnitude(-15/scale))); glxVertex3v(p.Plus(v.WithMagnitude(30/scale))); glEnd(); glxWriteText("(x, y) = (0, 0) for file just exported", DEFAULT_TEXT_HEIGHT, p.Plus(u.ScaledBy(10/scale)).Plus(v.ScaledBy(10/scale)), u, v, NULL, NULL); glxWriteText("press Esc to clear this message", DEFAULT_TEXT_HEIGHT, p.Plus(u.ScaledBy(40/scale)).Plus( v.ScaledBy(-(DEFAULT_TEXT_HEIGHT)/scale)), u, v, NULL, NULL); } // And finally the toolbar. if(SS.showToolbar) { ToolbarDraw(); } }
void EDA_3D_CANVAS::Redraw() { // SwapBuffer requires the window to be shown before calling if( !IsShownOnScreen() ) return; wxString err_messages; WX_STRING_REPORTER errorReporter( &err_messages ); STATUS_TEXT_REPORTER activityReporter( Parent(), 0 ); // Display build time at the end of build unsigned strtime = GetRunningMicroSecs(); SetCurrent( *m_glRC ); // Set the OpenGL viewport according to the client size of this canvas. // This is done here rather than in a wxSizeEvent handler because our // OpenGL rendering context (and thus viewport setting) is used with // multiple canvases: If we updated the viewport in the wxSizeEvent // handler, changing the size of one canvas causes a viewport setting that // is wrong when next another canvas is repainted. wxSize size = GetClientSize(); InitGL(); if( isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) ) { generateFakeShadowsTextures( &errorReporter, &activityReporter ); } // *MUST* be called *after* SetCurrent( ): glViewport( 0, 0, size.x, size.y ); // clear color and depth buffers glClearColor( 0.95, 0.95, 1.0, 1.0 ); glClearStencil( 0 ); glClearDepth( 1.0 ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); glShadeModel( GL_SMOOTH ); // Draw background glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glDisable( GL_LIGHTING ); glDisable( GL_COLOR_MATERIAL ); glDisable( GL_DEPTH_TEST ); glDisable( GL_TEXTURE_2D ); // Draw the background ( rectangle with color gradient) glBegin( GL_QUADS ); SetGLColor( GetPrm3DVisu().m_BgColor_Top, 1.0 ); glVertex2f( -1.0, 1.0 ); // Top left corner SetGLColor( GetPrm3DVisu().m_BgColor, 1.0 ); glVertex2f( -1.0,-1.0 ); // bottom left corner glVertex2f( 1.0,-1.0 ); // bottom right corner SetGLColor( GetPrm3DVisu().m_BgColor_Top, 1.0 ); glVertex2f( 1.0, 1.0 ); // top right corner glEnd(); glEnable( GL_DEPTH_TEST ); // set viewing projection glMatrixMode( GL_PROJECTION ); glLoadIdentity(); #define MAX_VIEW_ANGLE 160.0 / 45.0 if( GetPrm3DVisu().m_Zoom > MAX_VIEW_ANGLE ) GetPrm3DVisu().m_Zoom = MAX_VIEW_ANGLE; if( Parent()->ModeIsOrtho() ) { // OrthoReductionFactor is chosen to provide roughly the same size as // Perspective View const double orthoReductionFactor = 400 / GetPrm3DVisu().m_Zoom; // Initialize Projection Matrix for Ortographic View glOrtho( -size.x / orthoReductionFactor, size.x / orthoReductionFactor, -size.y / orthoReductionFactor, size.y / orthoReductionFactor, 1, 100 ); } else { // Ratio width / height of the window display double ratio_HV = (double) size.x / size.y; // Initialize Projection Matrix for Perspective View gluPerspective( 45.0f * GetPrm3DVisu().m_Zoom, ratio_HV, 1, 100 ); } // position viewer glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef( 0.0f, 0.0f, -(m_ZBottom + m_ZTop) / 2.0f ); // Setup light sources: SetLights(); CheckGLError( __FILE__, __LINE__ ); glMatrixMode( GL_MODELVIEW ); // position viewer // transformations GLfloat mat[4][4]; // Translate motion first, so rotations don't mess up the orientation... glTranslatef( m_draw3dOffset.x, m_draw3dOffset.y, 0.0F ); build_rotmatrix( mat, GetPrm3DVisu().m_Quat ); glMultMatrixf( &mat[0][0] ); glRotatef( GetPrm3DVisu().m_Rot[0], 1.0, 0.0, 0.0 ); glRotatef( GetPrm3DVisu().m_Rot[1], 0.0, 1.0, 0.0 ); glRotatef( GetPrm3DVisu().m_Rot[2], 0.0, 0.0, 1.0 ); if( ! m_glLists[GL_ID_BOARD] || ! m_glLists[GL_ID_TECH_LAYERS] ) CreateDrawGL_List( &errorReporter, &activityReporter ); if( isEnabled( FL_AXIS ) && m_glLists[GL_ID_AXIS] ) glCallList( m_glLists[GL_ID_AXIS] ); // move the board in order to draw it with its center at 0,0 3D coordinates glTranslatef( -GetPrm3DVisu().m_BoardPos.x * GetPrm3DVisu().m_BiuTo3Dunits, -GetPrm3DVisu().m_BoardPos.y * GetPrm3DVisu().m_BiuTo3Dunits, 0.0f ); if( isEnabled( FL_MODULE ) ) { if( ! m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] ) CreateDrawGL_List( &errorReporter, &activityReporter ); } glEnable( GL_LIGHTING ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); if( isRealisticMode() && isEnabled( FL_RENDER_TEXTURES ) ) glEnable( GL_TEXTURE_2D ); else glDisable( GL_TEXTURE_2D ); // Set material for the board glEnable( GL_COLOR_MATERIAL ); SetOpenGlDefaultMaterial(); //glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, FALSE ); // Board Body GLint shininess_value = 32; glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value ); if( isEnabled( FL_SHOW_BOARD_BODY ) ) { if( m_glLists[GL_ID_BODY] ) { glCallList( m_glLists[GL_ID_BODY] ); } } // Board // specify material parameters for the lighting model. shininess_value = 52; glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value ); glm::vec4 specular( GetPrm3DVisu().m_CopperColor.m_Red * 0.20f, GetPrm3DVisu().m_CopperColor.m_Green * 0.20f, GetPrm3DVisu().m_CopperColor.m_Blue * 0.20f, 1.0f ); glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.x ); if( m_glLists[GL_ID_BOARD] ) { glCallList( m_glLists[GL_ID_BOARD] ); } // Tech layers shininess_value = 32; glMateriali( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value ); glm::vec4 specularTech( 0.0f, 0.0f, 0.0f, 1.0f ); glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specularTech.x ); if( m_glLists[GL_ID_TECH_LAYERS] ) { glCallList( m_glLists[GL_ID_TECH_LAYERS] ); } if( isEnabled( FL_COMMENTS ) || isEnabled( FL_ECO ) ) { if( ! m_glLists[GL_ID_AUX_LAYERS] ) CreateDrawGL_List( &errorReporter, &activityReporter ); glCallList( m_glLists[GL_ID_AUX_LAYERS] ); } //glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, TRUE ); // Draw Component Shadow if( isEnabled( FL_MODULE ) && isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) ) { glEnable( GL_CULL_FACE ); glDisable( GL_DEPTH_TEST ); glEnable( GL_COLOR_MATERIAL ) ; SetOpenGlDefaultMaterial(); glColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); glEnable( GL_TEXTURE_2D ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); if( m_glLists[GL_ID_SHADOW_FRONT] ) { glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_front ); glCallList( m_glLists[GL_ID_SHADOW_FRONT] ); } if( m_glLists[GL_ID_SHADOW_BACK] ) { glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_back ); glCallList( m_glLists[GL_ID_SHADOW_BACK] ); } glColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); glEnable( GL_DEPTH_TEST ); glDisable( GL_TEXTURE_2D ); glDisable( GL_CULL_FACE ); } glEnable( GL_COLOR_MATERIAL ); SetOpenGlDefaultMaterial(); glDisable( GL_BLEND ); // Draw Solid Shapes if( isEnabled( FL_MODULE ) ) { if( ! m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] ) CreateDrawGL_List( &errorReporter, &activityReporter ); glCallList( m_glLists[GL_ID_3DSHAPES_SOLID_FRONT] ); } glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // Grid uses transparency: draw it after all objects if( isEnabled( FL_GRID ) ) { if( ! m_glLists[GL_ID_GRID] ) CreateDrawGL_List( &errorReporter, &activityReporter ); glCallList( m_glLists[GL_ID_GRID] ); } // Draw Board Shadow if( isRealisticMode() && isEnabled( FL_RENDER_SHADOWS ) ) { if( m_glLists[GL_ID_SHADOW_BOARD] ) { glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glColor4f( 1.0, 1.0, 1.0, 0.75f ); glEnable( GL_CULL_FACE ); glDisable( GL_COLOR_MATERIAL ); glEnable( GL_TEXTURE_2D ); glBindTexture( GL_TEXTURE_2D, m_text_fake_shadow_board ); glCallList( m_glLists[GL_ID_SHADOW_BOARD] ); glDisable( GL_CULL_FACE ); glDisable( GL_TEXTURE_2D ); } } // This list must be drawn last, because it contains the // transparent gl objects, which should be drawn after all // non transparent objects if( isEnabled( FL_MODULE ) && m_glLists[GL_ID_3DSHAPES_TRANSP_FRONT] ) { glEnable( GL_COLOR_MATERIAL ); SetOpenGlDefaultMaterial(); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glCallList( m_glLists[GL_ID_3DSHAPES_TRANSP_FRONT] ); } // Debug bounding boxes /* glDisable( GL_BLEND ); glDisable( GL_COLOR_MATERIAL ); glDisable( GL_LIGHTING ); glColor4f( 1.0f, 0.0f, 1.0f, 1.0f ); m_fastAABBox_Shadow.GLdebug(); glColor4f( 0.0f, 1.0f, 1.0f, 1.0f ); m_boardAABBox.GLdebug(); */ SwapBuffers(); // Show calculation time if some activity was reported if( activityReporter.HasMessage() ) { // Calculation time in seconds double calculation_time = (double)( GetRunningMicroSecs() - strtime) / 1e6; activityReporter.Report( wxString::Format( _( "Build time %.3f s" ), calculation_time ) ); } else activityReporter.Report( wxEmptyString ); if( !err_messages.IsEmpty() ) wxLogMessage( err_messages ); }
/* Init the models */ void init(void){ /* Create the robot base */ Model* base = new_cube(ROBOT_X_ORIGIN, ROBOT_Y_ORIGIN, ROBOT_Z_ORIGIN, update_base); models.push_back(base); /* Create the lower arm */ Model* lower_arm = new_cube(ROBOT_X_ORIGIN, ROBOT_Y_ORIGIN, ROBOT_Z_ORIGIN, update_lower_arm); models.push_back(lower_arm); /* Create the upper arm */ Model* upper_arm = new_cube(ROBOT_X_ORIGIN, ROBOT_Y_ORIGIN, ROBOT_Z_ORIGIN, update_upper_arm); models.push_back(upper_arm); /* Create the first shapes */ for(int i=0;i<SHAPE_SIZE;i++){ Model* m = new_shape(i); models.push_back(m); shape_t s; s.model = m; shapes[i].push_back(s); } /* Create the second shapes */ for(int i=0;i<SHAPE_SIZE;i++){ Model* m = new_shape(i); models.push_back(m); shape_t s; s.model = m; shapes[i].push_back(s); } /* Update colors as random */ update_colors(); /* Select the hold and true shape */ hold_shape = shapes[0][0].model; hold_shape->update = update_holded; true_shape = shapes[0][1].model; /* Init the all models */ for(list<Model*>::iterator i = models.begin();i != models.end();i++){ (*i)->point_init(); (*i)->apply_material(diffuse, ambient, specular, shininess); (*i)->lightp = light_p; } /* Init the view matrix */ view = LookAt(eye_point, look_at_point, vec3(0.0,1.0,0.0)); view *= RotateX(ROTATE_X); view *= RotateY(ROTATE_Y); projection = Perspective(fovy, aspect, z_near, z_far); /* Enable some features */ glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glClearDepth(1.0); glEnable(GL_MULTISAMPLE); glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST); glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glClearColor(0, 0, 0, 0); /* Init the clock */ past = clock(); }
void COGLGraphicsContext::UpdateFrame(bool swaponly) { status.gFrameCount++; glFlush(); OPENGL_CHECK_ERRORS; //glFinish(); //wglSwapIntervalEXT(0); /* if (debuggerPauseCount == countToPause) { static int iShotNum = 0; // get width, height, allocate buffer to store image int width = windowSetting.uDisplayWidth; int height = windowSetting.uDisplayHeight; printf("Saving debug images: width=%i height=%i\n", width, height); short *buffer = (short *) malloc(((width+3)&~3)*(height+1)*4); glReadBuffer( GL_FRONT ); // set up a BMGImage struct struct BMGImageStruct img; memset(&img, 0, sizeof(BMGImageStruct)); InitBMGImage(&img); img.bits = (unsigned char *) buffer; img.bits_per_pixel = 32; img.height = height; img.width = width; img.scan_width = width * 4; // store the RGB color image char chFilename[64]; sprintf(chFilename, "dbg_rgb_%03i.png", iShotNum); glReadPixels(0,0,width,height, GL_BGRA, GL_UNSIGNED_BYTE, buffer); WritePNG(chFilename, img); // store the Z buffer sprintf(chFilename, "dbg_Z_%03i.png", iShotNum); glReadPixels(0,0,width,height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buffer); //img.bits_per_pixel = 16; //img.scan_width = width * 2; WritePNG(chFilename, img); // dump a subset of the Z data for (int y = 0; y < 480; y += 16) { for (int x = 0; x < 640; x+= 16) printf("%4hx ", buffer[y*640 + x]); printf("\n"); } printf("\n"); // free memory and get out of here free(buffer); iShotNum++; } */ // if emulator defined a render callback function, call it before buffer swap if(renderCallback) (*renderCallback)(status.bScreenIsDrawn); CoreVideo_GL_SwapBuffers(); /*if(options.bShowFPS) { static unsigned int lastTick=0; static int frames=0; unsigned int nowTick = SDL_GetTicks(); frames++; if(lastTick + 5000 <= nowTick) { char caption[200]; sprintf(caption, "%s v%i.%i.%i - %.3f VI/S", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION), frames/5.0); CoreVideo_SetCaption(caption); frames = 0; lastTick = nowTick; } }*/ glDepthMask(GL_TRUE); OPENGL_CHECK_ERRORS; glClearDepth(1.0f); OPENGL_CHECK_ERRORS; if( !g_curRomInfo.bForceScreenClear ) { glClear(GL_DEPTH_BUFFER_BIT); OPENGL_CHECK_ERRORS; } else needCleanScene = true; status.bScreenIsDrawn = false; }
void CPreviewDlg::display_func(){ static bool init = false; static timemeas_t tm; static double realtime = 0.; if(!init){ init = true; TimeMeasStart(&tm); } double t1 = TimeMeasLap(&tm); double rdt, dt; /* if(g_fix_dt) rdt = g_fix_dt; else*/ rdt = (t1 - realtime); realtime = t1; dt = !init ? 0. : rdt < 1. ? rdt : 1.; MotionPose *dnmv = main.dnmv; /* if(main.dnmv){ if(fmod(realtime, .2) < .1){ dnmv->target = GetSrfName(main.selectbone); } else dnmv->target = NULL; }*/ glClearColor(0,0,0,0); glClearDepth(1.); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslated(0,0,-dist); gldMultQuat(viewrot); /* grid draw */ glPushMatrix(); gldScaled(100.); glBegin(GL_LINES); for(int i = 0; i <= 16; i++){ glColor4ub(255,127,127,255); glVertex3d(-8, 0, i - 8); glVertex3d( 8, 0, i - 8); glColor4ub(127,127,255,255); glVertex3d(i - 8, 0, -8); glVertex3d(i - 8, 0, 8); } glColor4ub(255,0,0,255); glVertex3d(-100,0,0); glVertex3d( 100,0,0); glColor4ub(0,255,0,255); glVertex3d(0,-100,0); glVertex3d(0, 100,0); glColor4ub(0,0,255,255); glVertex3d(0,0,-100); glVertex3d(0,0, 100); glEnd(); glPopMatrix(); if(main.dnm){ glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT); if(wireframe) glPolygonMode(GL_FRONT, GL_LINE); else glPolygonMode(GL_FRONT, GL_FILL); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); { int i; GLfloat mat_specular[] = {0., 0., 0., 1.}; GLfloat mat_diffuse[] = { .5, .5, .5, 1.0 }; GLfloat mat_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[4] = { 1, 1, 1, 0.0 }; GLfloat light_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 }; GLfloat light_diffuse[] = { 1., 1., 1., 1.0 }; glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightfv(GL_LIGHT0, GL_SPECULAR, mat_specular); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient_color); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); } glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // DrawYSDNM_V(main.dnm, main.dnmv); glPopAttrib(); /* if(boneview){ if(boneview == 2) glDisable(GL_DEPTH_TEST); glPushMatrix(); BoneYSDNM_V(main.dnm, main.dnmv); glPopMatrix(); }*/ } else if(main.model){ glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT); if(wireframe) glPolygonMode(GL_FRONT, GL_LINE); else glPolygonMode(GL_FRONT, GL_FILL); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); { int i; GLfloat mat_specular[] = {0., 0., 0., 1.}; GLfloat mat_diffuse[] = { .5, .5, .5, 1.0 }; GLfloat mat_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[4] = { 1, 1, 1, 0.0 }; GLfloat light_ambient_color[] = { 0.5, 0.5, 0.5, 1.0 }; GLfloat light_diffuse[] = { 1., 1., 1., 1.0 }; glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightfv(GL_LIGHT0, GL_SPECULAR, mat_specular); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient_color); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); } glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); // for(int i = 0; i < nsufs; i++){ // DrawSUF(sufs[i], SUF_ATR, NULL); // } // BoneMQO_V(sufs, bones, dnmv); // DrawMQO_V(main.model, dnmv); DrawMQOPose(main.model, dnmv); glPopAttrib(); /* if(boneview){ if(boneview == 2) glDisable(GL_DEPTH_TEST); glPushMatrix(); glBegin(GL_LINES); for(int i = 0; i < nsufs; i++){ glVertex3dv(bones[i]->parent ? bones[i]->parent->joint: Vec4d(0,0,0,0)); glVertex3dv(bones[i]->joint); } glEnd(); glPopMatrix(); }*/ } if(main.dnm){ glDisable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslated(0,0,-.5); ysdnm_t *dnm = main.dnm; int selectbone = main.selectbone; Motion *&motion = main.motion; Motion *(&motions)[16] = main.motions; int nmotions = main.nmotions, curmotion = main.curmotion; double (&motion_time)[16] = main.motion_time; glScaled(2. / g_width, 2. / g_height, 1.); glColor4ub(0,255,0,255); glRasterPos2d(-g_width / 2, -g_height / 2 + 32); gldprintf("bone: %d", selectbone); if(0 <= selectbone && selectbone < dnm->ns && dnm->s[selectbone]){ glRasterPos2d(-g_width / 2, -g_height / 2 + 16); gldprintf("name: \"%s\" \"%s\"", dnm->s[selectbone]->name, dnm->s[selectbone]->pck->name); } const double (*pq)[7]; if(pq = (double (*)[7])FindBone(selectbone)){ glRasterPos2d(-g_width / 2, -g_height / 2 + 0); gldprintf("rot: (%lg,%lg,%lg,%lg),(%lg,%lg,%lg)", (*pq)[0], (*pq)[1], (*pq)[2], (*pq)[3], (*pq)[4], (*pq)[5], (*pq)[6]); } /* if(motion && motion->kfl.size()){ glRasterPos2d(-g_width / 2, -g_height * 2 / 3); gldprintf("mot: (%d)", &motion->getKeyframe(motion_time[curmotion]) - motion->kfl); }*/ for(int n = 0; n < nmotions; n++) if(motions[n] && motions[n]->kfl.size()){ Motion *mot = motions[n]; double ttime = mot->totalTime(); glColor4ub(0,n == curmotion ? 255 : 127,0,255); glBegin(GL_LINE_LOOP); glVertex2d(-g_width / 2 * .8, -g_height / 2 * (.7 + .1 * n)); glVertex2d( g_width / 2 * .8, -g_height / 2 * (.7 + .1 * n)); glVertex2d( g_width / 2 * .8, -g_height / 2 * (.6 + .1 * n)); glVertex2d(-g_width / 2 * .8, -g_height / 2 * (.6 + .1 * n)); glEnd(); glBegin(GL_LINES); double tsum = 0.; for(int i = 0; i < mot->kfl.size(); i++){ tsum += mot->kfl[i].dt; glVertex2d(-g_width / 2 * .8 + tsum * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.7 + .1 * n)); glVertex2d(-g_width / 2 * .8 + tsum * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.6 + .1 * n)); } glColor4ub(255,255,0,255); glVertex2d(-g_width / 2 * .8 + motion_time[n] * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.7 + .1 * n)); glVertex2d(-g_width / 2 * .8 + motion_time[n] * (g_width / 2 * 1.6) / ttime, -g_height / 2 * (.6 + .1 * n)); glEnd(); } glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); } }
void RenderTexture::draw() { if( _autoDraw) { begin(); if (_clearFlags) { GLfloat oldClearColor[4] = {0.0f}; GLfloat oldDepthClearValue = 0.0f; GLint oldStencilClearValue = 0; // backup and set if (_clearFlags & GL_COLOR_BUFFER_BIT) { glGetFloatv(GL_COLOR_CLEAR_VALUE, oldClearColor); glClearColor(_clearColor.r, _clearColor.g, _clearColor.b, _clearColor.a); } if (_clearFlags & GL_DEPTH_BUFFER_BIT) { glGetFloatv(GL_DEPTH_CLEAR_VALUE, &oldDepthClearValue); glClearDepth(_clearDepth); } if (_clearFlags & GL_STENCIL_BUFFER_BIT) { glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &oldStencilClearValue); glClearStencil(_clearStencil); } // clear glClear(_clearFlags); // restore if (_clearFlags & GL_COLOR_BUFFER_BIT) { glClearColor(oldClearColor[0], oldClearColor[1], oldClearColor[2], oldClearColor[3]); } if (_clearFlags & GL_DEPTH_BUFFER_BIT) { glClearDepth(oldDepthClearValue); } if (_clearFlags & GL_STENCIL_BUFFER_BIT) { glClearStencil(oldStencilClearValue); } } //! make sure all children are drawn sortAllChildren(); Object *pElement; CCARRAY_FOREACH(_children, pElement) { Node *child = static_cast<Node*>(pElement); if (child != _sprite) { child->visit(); } } end(); }
/** * Function for initialization. */ GLUSboolean init(GLUSvoid) { // Points of a cube. GLfloat points[] = { -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f }; // Normals of a cube. GLfloat normals[] = { +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f }; // The associated indices. GLuint indices[] = { 0, 2, 1, 0, 3, 2, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 15, 14, 12, 14, 13, 16, 17, 18, 16, 18, 19, 20, 23, 22, 20, 22, 21 }; GLUStgaimage image; GLUStextfile vertexSource; GLUStextfile fragmentSource; // Load the source of the vertex shader. glusLoadTextFile("../src/Example07/Vertex.vs", &vertexSource); // Load the source of the fragment shader. glusLoadTextFile("../src/Example07/Fragment.fs", &fragmentSource); // Build and ... glusBuildProgram(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text); // Destroy the text resource glusDestroyTextFile(&vertexSource); // Destroy the text resource glusDestroyTextFile(&fragmentSource); // ToDo: glGenVertexArrays(1, &g_vao); // ToDo: glBindVertexArray(g_vao); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_inverseCameraLocation = glGetUniformLocation(g_program.program, "inverseCameraMatrix"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_cubemapLocation = glGetUniformLocation(g_program.program, "cubemap"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml g_vertexLocation = glGetAttribLocation(g_program.program, "vertex"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml g_normalLocation = glGetAttribLocation(g_program.program, "normal"); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_vertices); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_vertices); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ARRAY_BUFFER, 24 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_normals); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_normals); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ARRAY_BUFFER, 24 * 3 * sizeof(GLfloat), (GLfloat*) normals, GL_STATIC_DRAW); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_indices); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indices); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * 2 * 3 * sizeof(GLuint), (GLuint*) indices, GL_STATIC_DRAW); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html glGenTextures(1, &g_cubemap); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap); glusLoadTgaImage("cm_left.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_right.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_top.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_bottom.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_back.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_front.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); // http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml glUseProgram(g_program.program); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_vertices); // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml glEnableVertexAttribArray(g_vertexLocation); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_normals); // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml glEnableVertexAttribArray(g_normalLocation); // http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml glUniform1i(g_cubemapLocation, 0); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/cleardepth.html glClearDepth(1.0f); //http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html glEnable( GL_DEPTH_TEST); //http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html glEnable( GL_CULL_FACE); return GLUS_TRUE; }
static void glfw_newwindow(char* name, int heigth, int width) { int major, minor, rev; GLenum error; GLuint shaders[2]; GLint data[4]; GLfloat vertexData[] = { // X Y Z -1.0f,-1.0f,-1.0f, 0.0f, 0.0f, -1.0f, 1.0f,-1.0f, 0.0f, 1.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, 1.0f,-1.0f,-1.0f, 1.0f, 0.0f, -1.0f, 1.0f,-1.0f, 0.0f, 1.0f, 1.0f, 1.0f,-1.0f, 1.0f, 1.0f }; glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE); if(!glfwOpenWindow(width, heigth, 8, 8, 8, 8, 16, 0, GLFW_WINDOW)) printf("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?"); if(glewInit() != GLEW_OK) printf("glewInit failed"); glShadeModel(GL_SMOOTH); glClearColor(0.0f, 0.0f, 0.3f, 0.0f); glClearDepth(1.0f); // Depth Buffer Setup glEnable(GL_BLEND); glEnable(GL_DEPTH_TEST); // Enables Depth Testing glEnable(GL_TEXTURE_2D); glDepthFunc(GL_LEQUAL); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glAlphaFunc( GL_GREATER, 0 ); glEnable(GL_POLYGON_SMOOTH); // print out some info about the graphics drivers printf( "OpenGL version: %s \n", glGetString(GL_VERSION)); printf( "GLSL version: %s \n",glGetString(GL_SHADING_LANGUAGE_VERSION)); printf("Vendor: %s\n",glGetString(GL_VENDOR)); printf("Renderer: %s\n",glGetString(GL_RENDERER)); shaders[0] = ShaderCreateFromStr(GL_VERTEX_SHADER, vertexShader); shaders[1] = ShaderCreateFromStr(GL_FRAGMENT_SHADER, fragmentShader); program = ShaderCreateProgram(shaders, 2); shaders[0] = ShaderCreateFromStr(GL_VERTEX_SHADER, vertexShader_gui); shaders[1] = ShaderCreateFromStr(GL_FRAGMENT_SHADER, fragmentShader); program_gui = ShaderCreateProgram(shaders, 2); USE_PROGRAM(program); error = glGetError(); if(error != GL_NO_ERROR) printf( "OpenGL Error %d: %s\n", error, (const char*)glewGetErrorString(error)); /*glm::mat4 camera = glm::lookAt(glm::vec3(0,0,1), glm::vec3(0,0,0), glm::vec3(0,1,0)); ShaderSetUniform(ShaderGetUniform(program,"camera"), 1, glm::value_ptr(camera)); */ glfwSetCamera( 0, 0, 1); glm::mat4 projection = glm::perspective<float>(60.0, 800.0f/600, 0.01, 10.0); ShaderSetUniform(ShaderGetUniform(currentProgram,"projection"), 1, glm::value_ptr(projection)); glm::mat4 rotation = glm::rotate(glm::mat4(), 0.0f, glm::vec3(0,1,0)); ShaderSetUniform(ShaderGetUniform(currentProgram,"model"),1, glm::value_ptr(rotation)); ShaderSetUniformInt(ShaderGetUniform(currentProgram,"debug"), 1); ShaderSetUniform4f(ShaderGetUniform(currentProgram,"debugcolor"), 0.0, 0, 0, 0.0f); USE_PROGRAM(0); USE_PROGRAM(program_gui); glfwSetCamera_ext( "projection", 0,0, 60); rotation = glm::rotate(glm::mat4(), 0.0f, glm::vec3(0,1,0)); ShaderSetUniform(ShaderGetUniform(currentProgram,"model"),1, glm::value_ptr(rotation)); ShaderSetUniformInt(ShaderGetUniform(currentProgram,"debug"), 1); ShaderSetUniform4f(ShaderGetUniform(currentProgram,"debugcolor"), 0.0, 0, 0, 0.0f); glUseProgram(0); glGenVertexArrays(1, &gVAO); glBindVertexArray(gVAO); // make and bind the VBO glGenBuffers(1, &gVBO); glBindBuffer(GL_ARRAY_BUFFER, gVBO); // Put the three triangle verticies into the VBO glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW); // connect the xyz to the "vert" attribute of the vertex shader glEnableVertexAttribArray(ShaderGetAttrib(program, "vert")); glVertexAttribPointer(ShaderGetAttrib(program, "vert"), 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), NULL); // connect the uv coords to the "vertTexCoord" attribute of the vertex shader glEnableVertexAttribArray(ShaderGetAttrib(program,"vertTexCoord")); glVertexAttribPointer(ShaderGetAttrib(program,"vertTexCoord"), 2, GL_FLOAT, GL_TRUE, 5*sizeof(GLfloat), (const GLvoid*)(3 * sizeof(GLfloat))); // connect the xyz to the "vert" attribute of the vertex shader glEnableVertexAttribArray(ShaderGetAttrib(program_gui, "vert")); glVertexAttribPointer(ShaderGetAttrib(program_gui, "vert"), 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), NULL); // connect the uv coords to the "vertTexCoord" attribute of the vertex shader glEnableVertexAttribArray(ShaderGetAttrib(program_gui,"vertTexCoord")); glVertexAttribPointer(ShaderGetAttrib(program_gui,"vertTexCoord"), 2, GL_FLOAT, GL_TRUE, 5*sizeof(GLfloat), (const GLvoid*)(3 * sizeof(GLfloat))); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); error = glGetError(); if(error != GL_NO_ERROR) printf( "OpenGL Error %d: %s\n", error, (const char*)glewGetErrorString(error)); glfwSetMousePos(800/2, 600/2); glfwDisable(GLFW_MOUSE_CURSOR); }
//Set up openGL bool GLInit() { //set viewport int height = 480; int width = 640; glViewport(0, 0, width, height); //reset viewport //set up projection matrix glMatrixMode(GL_PROJECTION); //select projection matrix glLoadIdentity(); //reset gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f); //load identity modelview glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //other states //shading glShadeModel(GL_SMOOTH); glClearColor( backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); //depth glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); //hints glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //Set up vertex arrays for torus //Fixed 17th November 2002 //Instead of passing tangents as texture coords 1 and 2, use aliased attributes 9 and 10. //This way, these texture coordinates will reach the vertex program on a geforce 2 //which only has 2 texture units. glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position); glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].normal); //Pass texture coords to unit 0 glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s); //Pass tangent,binormal to attributes 9, 10 glEnableClientState(GL_VERTEX_ATTRIB_ARRAY9_NV); glVertexAttribPointerNV(9, 3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].sTangent); glEnableClientState(GL_VERTEX_ATTRIB_ARRAY10_NV); glVertexAttribPointerNV(10, 3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].tTangent); //Use compiled vertex arrays glLockArraysEXT(0, torus.numVertices); //Load vertex programs glGenProgramsNV(1, &singlePassVertexProgram); glBindProgramNV(GL_VERTEX_PROGRAM_NV, singlePassVertexProgram); LoadNV_vertex_program("single pass vertex program.txt", singlePassVertexProgram); glGenProgramsNV(1, &diffuseDecalVertexProgram); glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseDecalVertexProgram); LoadNV_vertex_program("diffuse decal vertex program.txt", diffuseDecalVertexProgram); glGenProgramsNV(1, &lookUpSpecularVertexProgram); glBindProgramNV(GL_VERTEX_PROGRAM_NV, lookUpSpecularVertexProgram); LoadNV_vertex_program("look up specular vertex program.txt", lookUpSpecularVertexProgram); glGenProgramsNV(1, &diffuseVertexProgram); glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseVertexProgram); LoadNV_vertex_program("diffuse vertex program.txt", diffuseVertexProgram); glGenProgramsNV(1, &decalVertexProgram); glBindProgramNV(GL_VERTEX_PROGRAM_NV, decalVertexProgram); LoadNV_vertex_program("decal vertex program.txt", decalVertexProgram); glGenProgramsNV(1, &simpleSpecularVertexProgram); glBindProgramNV(GL_VERTEX_PROGRAM_NV, simpleSpecularVertexProgram); LoadNV_vertex_program("simple specular vertex program.txt", simpleSpecularVertexProgram); //Set Tracking Matrix //Modelview Projection in registers c[0]-c[3] glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); return true; }
void Scene::render(RenderContext* renderContext) { renderContext->scene = this; renderContext->viewpoint = viewpoint; // // CLEAR BUFFERS // GLbitfield clearFlags = 0; // Depth Buffer glClearDepth(1.0); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); // if ( unsortedShapes.size() ) clearFlags |= GL_DEPTH_BUFFER_BIT; // Color Buffer (optional - depends on background node) clearFlags |= background->getClearFlags(renderContext); // clear glClear(clearFlags); // renderContext.clear(viewport); // userMatrix and scale might change the length of normals. If this slows us // down, we should test for that instead of just enabling GL_NORMALIZE glEnable(GL_NORMALIZE); // // SETUP LIGHTING MODEL // setupLightModel(renderContext); Sphere total_bsphere; if (data_bbox.isValid()) { // // GET DATA VOLUME SPHERE // total_bsphere = Sphere( (bboxDeco) ? bboxDeco->getBoundingBox(data_bbox) : data_bbox ); } else { total_bsphere = Sphere( Vertex(0,0,0), 1 ); } // // SETUP VIEWPORT TRANSFORMATION // glViewport(renderContext->rect.x,renderContext->rect.y,renderContext->rect.width, renderContext->rect.height); // // SETUP BACKGROUND VIEWPOINT PROJECTION // // FIXME: move to background // viewpoint->setupFrustum( renderContext, total_bsphere ); // // RENDER BACKGROUND // // DISABLE Z-BUFFER TEST glDisable(GL_DEPTH_TEST); // DISABLE Z-BUFFER FOR WRITING glDepthMask(GL_FALSE); background->render(renderContext); // // RENDER MODEL // if (data_bbox.isValid() ) { // // SETUP VIEWPOINT TRANSFORMATION // viewpoint->setupTransformation( renderContext, total_bsphere); // // RENDER BBOX DECO // if (bboxDeco) bboxDeco->render(renderContext); // // RENDER SOLID SHAPES // // ENABLE Z-BUFFER TEST glEnable(GL_DEPTH_TEST); // ENABLE Z-BUFFER FOR WRITING glDepthMask(GL_TRUE); // DISABLE BLENDING glDisable(GL_BLEND); { std::vector<Shape*>::iterator iter; for (iter = unsortedShapes.begin() ; iter != unsortedShapes.end() ; ++iter ) { Shape* shape = *iter; shape->render(renderContext); } } // #define NO_BLEND #ifndef NO_BLEND // // RENDER BLENDED SHAPES // // render shapes in bounding-box sorted order according to z value // // DISABLE Z-BUFFER FOR WRITING glDepthMask(GL_FALSE); // SETUP BLENDING glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // ENABLE BLENDING glEnable(GL_BLEND); // // GET THE TRANSFORMATION // viewpoint->setupTransformation(renderContext, total_bsphere); double data[16]; glGetDoublev(GL_MODELVIEW_MATRIX,data); Matrix4x4 M(data); glGetDoublev(GL_PROJECTION_MATRIX,data); Matrix4x4 P(data); P = P*M; renderContext->Zrow = P.getRow(2); renderContext->Wrow = P.getRow(3); { std::vector<Shape*>::iterator iter; std::multimap<float, int> distanceMap; int index = 0; for (iter = zsortShapes.begin() ; iter != zsortShapes.end() ; ++iter ) { Shape* shape = *iter; const AABox& aabox = shape->getBoundingBox(); float distance = renderContext->getDistance( aabox.getCenter() ); distanceMap.insert( std::pair<float,int>(-distance, index) ); index++; } { std::multimap<float,int>::iterator iter; for (iter = distanceMap.begin() ; iter != distanceMap.end() ; ++ iter ) { int index = iter->second; Shape* shape = zsortShapes[index]; shape->renderZSort(renderContext); } } } #endif /* Reset flag(s) now that scene has been rendered */ renderContext->viewpoint->scaleChanged = false; } }
GLUSuint initWaterTexture(GLUSfloat waterPlaneLength) { GLfloat projectionMatrixWaterTexture[16]; GLfloat modelViewMatrixWaterTexture[16]; GLUSshape plane; GLUStextfile vertexSource; GLUStextfile fragmentSource; glusLoadTextFile("../Example15/shader/WaterTexture.vert.glsl", &vertexSource); glusLoadTextFile("../Example15/shader/WaterTexture.frag.glsl", &fragmentSource); glusBuildProgramFromSource(&g_programWaterTexture, (const GLUSchar**) &vertexSource.text, 0, 0, 0, (const GLUSchar**) &fragmentSource.text); glusDestroyTextFile(&vertexSource); glusDestroyTextFile(&fragmentSource); // g_projectionMatrixWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_projectionMatrix"); g_modelViewMatrixWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_modelViewMatrix"); g_waterPlaneLengthWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waterPlaneLength"); g_passedTimeWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_passedTime"); g_waveParametersWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waveParameters"); g_waveDirectionsWaterTextureLocation = glGetUniformLocation(g_programWaterTexture.program, "u_waveDirections"); g_vertexWaterTextureLocation = glGetAttribLocation(g_programWaterTexture.program, "a_vertex"); g_texCoordWaterTextureLocation = glGetAttribLocation(g_programWaterTexture.program, "a_texCoord"); // glGenTextures(1, &g_mirrorTexture); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, g_mirrorTexture); glTexImage2D(GL_TEXTURE_2D, 0, GLUS_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GLUS_RGB, GL_UNSIGNED_BYTE, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glBindTexture(GL_TEXTURE_2D, 0); // glGenRenderbuffers(1, &g_depthMirrorTexture); glBindRenderbuffer(GL_RENDERBUFFER, g_depthMirrorTexture); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, TEXTURE_SIZE, TEXTURE_SIZE); glBindRenderbuffer(GL_RENDERBUFFER, 0); // glGenFramebuffers(1, &g_fboWaterTexture); glBindFramebuffer(GL_FRAMEBUFFER, g_fboWaterTexture); // Attach the color buffer ... glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_mirrorTexture, 0); // ... and the depth buffer, glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, g_depthMirrorTexture); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { printf("GL_FRAMEBUFFER_COMPLETE error 0x%x", glCheckFramebufferStatus(GL_FRAMEBUFFER)); return GLUS_FALSE; } glBindFramebuffer(GL_FRAMEBUFFER, 0); // glBindVertexArray(0); // glusCreatePlanef(&plane, TEXTURE_SIZE / 2.0f); g_numberIndicesWaterTexture = plane.numberIndices; glGenBuffers(1, &g_verticesWaterTextureVBO); glBindBuffer(GL_ARRAY_BUFFER, g_verticesWaterTextureVBO); glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 4 * sizeof(GLfloat), (GLfloat*) plane.vertices, GL_STATIC_DRAW); glGenBuffers(1, &g_texCoordsWaterTextureVBO); glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsWaterTextureVBO); glBufferData(GL_ARRAY_BUFFER, plane.numberVertices * 2 * sizeof(GLfloat), (GLfloat*) plane.texCoords, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &g_indicesWaterTextureVBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesWaterTextureVBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane.numberIndices * sizeof(GLuint), (GLuint*) plane.indices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glusDestroyShapef(&plane); // glUseProgram(g_programWaterTexture.program); glusLookAtf(modelViewMatrixWaterTexture, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); glUniformMatrix4fv(g_modelViewMatrixWaterTextureLocation, 1, GL_FALSE, modelViewMatrixWaterTexture); glusOrthof(projectionMatrixWaterTexture, -(GLfloat) TEXTURE_SIZE / 2, (GLfloat) TEXTURE_SIZE / 2, -(GLfloat) TEXTURE_SIZE / 2, (GLfloat) TEXTURE_SIZE / 2, 1.0f, 100.0f); glUniformMatrix4fv(g_projectionMatrixWaterTextureLocation, 1, GL_FALSE, projectionMatrixWaterTexture); glUniform1f(g_waterPlaneLengthWaterTextureLocation, waterPlaneLength); // glGenVertexArrays(1, &g_vaoWaterTexture); glBindVertexArray(g_vaoWaterTexture); glBindBuffer(GL_ARRAY_BUFFER, g_verticesWaterTextureVBO); glVertexAttribPointer(g_vertexWaterTextureLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_vertexWaterTextureLocation); glBindBuffer(GL_ARRAY_BUFFER, g_texCoordsWaterTextureVBO); glVertexAttribPointer(g_texCoordWaterTextureLocation, 2, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_texCoordWaterTextureLocation); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesWaterTextureVBO); // glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); return g_mirrorTexture; }
BOOL Initialize(void) { int i; char Line[255]; float shaderData[32][3]; FILE *In = NULL; glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glClearColor (0.7f, 0.7f, 0.7f, 0.0f); glClearDepth (1.0f); glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LESS); glShadeModel (GL_SMOOTH); glDisable (GL_LINE_SMOOTH); glEnable (GL_CULL_FACE); glDisable (GL_LIGHTING); In = fopen ("Data/Shader.txt", "r"); if (In) { for (i = 0; i < 32; i++) { if (feof (In)) break; fgets (Line, 255, In); shaderData[i][0] = shaderData[i][1] = shaderData[i][2] = (float)(atof (Line)); } fclose (In); } else { printf("Error loading file Shader.txt: Initialize\n"); return False; } glGenTextures (1, &shaderTexture[0]); glBindTexture (GL_TEXTURE_1D, shaderTexture[0]); glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage1D (GL_TEXTURE_1D, 0, GL_RGB, 32, 0, GL_RGB , GL_FLOAT, shaderData); lightAngle.X = 0.0f; lightAngle.Y = 0.0f; lightAngle.Z = 1.0f; Normalize (&lightAngle); return ReadMesh (); }
//////////////////////////////////////////////////////////// /// Entry point of application /// /// \return Application exit code /// //////////////////////////////////////////////////////////// int main() { // Create the main window sf::RenderWindow App(sf::VideoMode(800, 600, 32), "SFML OpenGL"); // Create a clock for measuring time elapsed sf::Clock Clock; // Set color and depth clear value glClearDepth(1.f); glClearColor(0.f, 0.f, 0.f, 0.f); // Enable Z-buffer read and write glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); // Setup a perspective projection glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(90.f, 800.0f/600.0f, 1.f, 500.f); // set FPS limit to 60 App.SetFramerateLimit(60); // Preserve OpenGl States App.PreserveOpenGLStates(true); // Create Cube Cube c; // Create design ygui::DesignButton d(200.0, 50.0); ygui::DesignButton d1(200.0, 50.0); ygui::DesignButton d2(50.0, 200.0); ygui::DesignButton d3(50.0, 200.0); // Create Button CubeButtonUp test(d, &c); CubeButtonDown test1(d1, &c); CubeButtonLeft test2(d2, &c); CubeButtonRight test3(d3, &c); // Create scene ygui::Scene scene; // Set button setting test.setX(300.0); test.setY(50.0); test.setText("Up"); test.setTextColor(0, 0, 0); test.setTextY(3.0); test.setTextX(80.0); test1.setX(300.0); test1.setY(500.0); test1.setText("Down"); test1.setTextColor(0, 0, 0); test1.setTextY(3.0); test1.setTextX(65.0); test2.setX(50.0); test2.setY(200.0); test2.setText("Left"); test2.setTextColor(0, 0, 0); test2.setTextX(5.0); test2.setTextY(125.0); test2.setTextRotation(90.0f); test3.setX(700.0); test3.setY(200.0); test3.setText("Right"); test3.setTextColor(0, 0, 0); test3.setTextX(45.0); test3.setTextY(55.0); test3.setTextRotation(270.0f); scene.addObject("1", &test); scene.addObject("2", &test1); scene.addObject("3", &test2); scene.addObject("4", &test3); // Start game loop while (App.IsOpened()) { // Process events sf::Event Event; while (App.GetEvent(Event)) { // Close window : exit if (Event.Type == sf::Event::Closed) App.Close(); // Escape key : exit if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape)) App.Close(); // Resize event : adjust viewport if (Event.Type == sf::Event::Resized) glViewport(0, 0, Event.Size.Width, Event.Size.Height); } // Set the active window before using OpenGL commands // It's useless here because active window is always the same, // but don't forget it if you use multiple windows or controls App.Clear(); App.SetActive(); // Clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Apply some transformations glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.f, 0.f, -200.f); c.draw(Clock); scene.draw(App); // Finally, display rendered frame on screen App.Display(); } return EXIT_SUCCESS; }
void DrawingFunction() { window.create(sf::VideoMode(800, 600), "Client"); //window.setFramerateLimit(60); // Set color and depth clear value glClearDepth(1.f); glClearColor(0.f, 0.f, 0.f, 0.f); // Enable Z-buffer read and write glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); // Setup a perspective projection gluPerspective(90.f, 1.f, 1.f, 500.f); while (window.isOpen()) { sf::Event event; while (window.pollEvent(event)) { if (event.type == sf::Event::Resized) { // adjust the viewport when the window is resized glViewport(0, 0, event.size.width, event.size.height); } else if (event.type == sf::Event::GainedFocus) { isActive = true; } else if (event.type == sf::Event::LostFocus) { isActive = false; } } // Input if (isActive) { if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) { world.GetClient()->Translate(-0.1f, 0, 0); std::cout << "MOVING: " << world.GetClient()->playerId << std::endl; } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) { world.GetClient()->Translate(0.1f, 0, 0); std::cout << "MOVING: " << world.GetClient()->playerId << std::endl; } if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) { world.GetClient()->Translate(0.0f, 0.1f, 0); std::cout << "MOVING: " << world.GetClient()->playerId << std::endl; } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) { world.GetClient()->Translate(0.0f, -0.1f, 0); std::cout << "MOVING: " << world.GetClient()->playerId << std::endl; } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Q)) { world.GetClient()->Translate(0.0f, 0.0f, -0.1f); std::cout << "MOVING: " << world.GetClient()->playerId << std::endl; } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::E)) { world.GetClient()->Translate(0.0f, 0.0f, 0.1f); std::cout << "MOVING: " << world.GetClient()->playerId << std::endl; } } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glBegin(GL_TRIANGLES); glColor3f(0.2f, 0.2f, 0.2f); // ??? world.DrawWorld(); // Draw all players glColor3f(1.0f, 0.0f, 0.0f); // RED world.DrawPlayers(); glEnd(); // triangles window.pushGLStates(); // SFML drawing sf::RectangleShape rectangle(sf::Vector2f(120, 50)); rectangle.setFillColor(sf::Color::Blue); rectangle.setPosition(0, 0); window.draw(rectangle); window.popGLStates(); // /SFML drawing window.display(); } }
int main() { int rotateX = 0; int rotateY = 0; //set mode 0, enable BG0 and set it to 3D videoSetMode(MODE_0_3D); // intialize gl glInit(); // enable antialiasing glEnable(GL_ANTIALIAS); // setup the rear plane glClearColor(0,0,0,31); // BG must be opaque for AA to work glClearPolyID(63); // BG must have a unique polygon ID for AA to work glClearDepth(0x7FFF); //this should work the same as the normal gl call glViewport(0,0,255,191); vramSetBankA(VRAM_A_TEXTURE); glEnable(GL_TEXTURE_2D); int cafe_texid; glGenTextures( 1, &cafe_texid ); glBindTexture( 0, cafe_texid ); glTexImage2D( 0, 0, GL_RGB, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, GL_TEXTURE_WRAP_S|GL_TEXTURE_WRAP_T|TEXGEN_NORMAL, (u8*)cafe_bin ); //any floating point gl call is being converted to fixed prior to being implemented glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(70, 256.0 / 192.0, 0.1, 40); while(1) { //TEXGEN_NORMAL helpfully pops our normals into this matrix and uses the result as texcoords glMatrixMode(GL_TEXTURE); glLoadIdentity(); GLvector tex_scale = { 64<<16, -64<<16, 1<<16 }; glScalev( &tex_scale ); //scale normals up from (-1,1) range into texcoords glRotateXi(rotateX); //rotate texture-matrix to match the camera glRotateYi(rotateY); glMatrixMode(GL_POSITION); glLoadIdentity(); glTranslatef32(0, 0, floattof32(-3)); glRotateXi(rotateX); glRotateYi(rotateY); glMaterialf(GL_EMISSION, RGB15(31,31,31)); glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK ); scanKeys(); u32 keys = keysHeld(); if( keys & KEY_UP ) rotateX += 3<<3; if( keys & KEY_DOWN ) rotateX -= 3<<3; if( keys & KEY_LEFT ) rotateY += 3<<3; if( keys & KEY_RIGHT ) rotateY -= 3<<3; int pen_delta[2]; get_pen_delta( &pen_delta[0], &pen_delta[1] ); rotateY -= pen_delta[0]; rotateX -= pen_delta[1]; glBindTexture( 0, cafe_texid ); glCallList((u32*)teapot_bin); glFlush(0); } return 0; }//end main
//Called to update the display. //You should call glutSwapBuffers after all of your rendering to display what you rendered. //If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function. void display() { g_lights.UpdateTime(); glm::vec4 bkg = g_lights.GetBackgroundColor(); glClearColor(bkg[0], bkg[1], bkg[2], bkg[3]); glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutil::MatrixStack modelMatrix; modelMatrix.SetMatrix(g_viewPole.CalcMatrix()); const glm::mat4 &worldToCamMat = modelMatrix.Top(); LightBlock lightData = g_lights.GetLightInformation(worldToCamMat); glBindBuffer(GL_UNIFORM_BUFFER, g_lightUniformBuffer); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(lightData), &lightData); glBindBuffer(GL_UNIFORM_BUFFER, 0); if(g_pScene) { glutil::PushStack push(modelMatrix); g_pScene->Draw(modelMatrix, g_materialBlockIndex, g_lights.GetTimerValue("tetra")); } { glutil::PushStack push(modelMatrix); //Render the sun { glutil::PushStack push(modelMatrix); glm::vec3 sunlightDir(g_lights.GetSunlightDirection()); modelMatrix.Translate(sunlightDir * 500.0f); modelMatrix.Scale(30.0f, 30.0f, 30.0f); glUseProgram(g_Unlit.theProgram); glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glm::vec4 lightColor = g_lights.GetSunlightIntensity(); glUniform4fv(g_Unlit.objectColorUnif, 1, glm::value_ptr(lightColor)); g_pScene->GetSphereMesh()->Render("flat"); } //Render the lights if(g_bDrawLights) { for(int light = 0; light < g_lights.GetNumberOfPointLights(); light++) { glutil::PushStack push(modelMatrix); modelMatrix.Translate(g_lights.GetWorldLightPosition(light)); glUseProgram(g_Unlit.theProgram); glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glm::vec4 lightColor = g_lights.GetPointLightIntensity(light); glUniform4fv(g_Unlit.objectColorUnif, 1, glm::value_ptr(lightColor)); g_pScene->GetCubeMesh()->Render("flat"); } } if(g_bDrawCameraPos) { glutil::PushStack push(modelMatrix); modelMatrix.SetIdentity(); modelMatrix.Translate(glm::vec3(0.0f, 0.0f, -g_viewPole.GetView().radius)); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glUseProgram(g_Unlit.theProgram); glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniform4f(g_Unlit.objectColorUnif, 0.25f, 0.25f, 0.25f, 1.0f); g_pScene->GetCubeMesh()->Render("flat"); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); glUniform4f(g_Unlit.objectColorUnif, 1.0f, 1.0f, 1.0f, 1.0f); g_pScene->GetCubeMesh()->Render("flat"); } } glutPostRedisplay(); glutSwapBuffers(); }
static void find_ideal_mrd(GLdouble *ideal_mrd_near, GLdouble *ideal_mrd_far, GLdouble *next_to_near, GLdouble *next_to_far) { /* MRD stands for Minimum Resolvable Difference, the smallest distance * in depth that suffices to separate any two polygons (or a polygon * and the near or far clipping planes). * * This function tries to determine the "ideal" MRD for the current * rendering context. It's expressed in window coordinates, because * the value in model or clipping coordinates depends on the scale * factors in the modelview and projection matrices and on the * distances to the near and far clipping planes. * * For simple unsigned-integer depth buffers that aren't too deep (so * that precision isn't an issue during coordinate transformations), * it should be about one least-significant bit. For deep or * floating-point or compressed depth buffers the situation may be * more complicated, so we don't pass or fail an implementation solely * on the basis of its ideal MRD. * * There are two subtle parts of this function. The first is the * projection matrix we use for rendering. This matrix places the far * clip plane at infinity (so that we don't run into arbitrary limits * during our search process). The second is the method used for * drawing the polygon. We scale the x and y coords of the polygon * vertices by the polygon's depth, so that it always occupies the * full view frustum. This makes it easier to verify that the polygon * was resolved completely -- we just read back the entire window and * see if any background pixels appear. * * To insure that we get reasonable results on machines with unusual * depth buffers (floating-point, or compressed), we determine the MRD * twice, once close to the near clipping plane and once as far away * from the eye as possible. On a simple integer depth buffer these * two values should be essentially the same. For other depth-buffer * formats, the ideal MRD is simply the largest of the two. */ GLdouble near_dist, far_dist, half_dist; int i; /* First, find a distance that is as far away as possible, yet a quad * at that distance can be distinguished from the background. Start * by pushing quads away from the eye until we find an interval where * the closer quad can be resolved, but the farther quad cannot. Then * binary-search to find the threshold. */ glDepthFunc(GL_LESS); glClearDepth(1.0); glColor3f(1.0, 0.0, 0.0); /* red */ near_dist = 1.0; far_dist = 2.0; for (;;) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); draw_quad_at_distance(far_dist); if (!red_quad_was_drawn()) break; piglit_present_results(); near_dist = far_dist; far_dist *= 2.0; } for (i = 0; i < 64; ++i) { half_dist = 0.5 * (near_dist + far_dist); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); draw_quad_at_distance(half_dist); if (red_quad_was_drawn()) near_dist = half_dist; else far_dist = half_dist; piglit_present_results(); } *next_to_far = near_dist; /* We can derive a resolvable difference from the value next_to_far, * but it's not necessarily the one we want. Consider mapping the * object coordinate range [0,1] onto the integer window coordinate * range [0,2]. A natural way to do this is with a linear function, * windowCoord = 2*objectCoord. With rounding, this maps [0,0.25) to * 0, [0.25,0.75) to 1, and [0.75,1] to 2. Note that the intervals at * either end are 0.25 wide, but the one in the middle is 0.5 wide. * The difference we can derive from next_to_far is related to the * width of the final interval. We want to back up just a bit so that * we can get a (possibly much larger) difference that will work for * the larger interval. To do this we need to find a difference that * allows us to distinguish two quads when the more distant one is at * distance next_to_far. */ near_dist = 1.0; far_dist = *next_to_far; for (i = 0; i < 64; ++i) { half_dist = 0.5 * (near_dist + far_dist); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColor3f(0.0, 0.0, 0.0); /* black */ glDepthFunc(GL_ALWAYS); draw_quad_at_distance(*next_to_far); glColor3f(1.0, 0.0, 0.0); /* red */ glDepthFunc(GL_LESS); draw_quad_at_distance(half_dist); if (red_quad_was_drawn()) near_dist = half_dist; else far_dist = half_dist; piglit_present_results(); } *ideal_mrd_far = window_coord_depth(*next_to_far) - window_coord_depth(near_dist); /* Now we apply a similar strategy at the near end of the depth range, * but swapping the senses of various comparisons so that we approach * the near clipping plane rather than the far. */ glClearDepth(0.0); glDepthFunc(GL_GREATER); glColor3f(1.0, 0.0, 0.0); /* red */ near_dist = 1.0; far_dist = *next_to_far; for (i = 0; i < 64; ++i) { half_dist = 0.5 * (near_dist + far_dist); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); draw_quad_at_distance(half_dist); if (red_quad_was_drawn()) far_dist = half_dist; else near_dist = half_dist; piglit_present_results(); } *next_to_near = far_dist; near_dist = *next_to_near; far_dist = *next_to_far; for (i = 0; i < 64; ++i) { half_dist = 0.5 * (near_dist + far_dist); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColor3f(0.0, 0.0, 0.0); /* black */ glDepthFunc(GL_ALWAYS); draw_quad_at_distance(*next_to_near); glColor3f(1.0, 0.0, 0.0); /* red */ glDepthFunc(GL_GREATER); draw_quad_at_distance(half_dist); if (red_quad_was_drawn()) far_dist = half_dist; else near_dist = half_dist; piglit_present_results(); } *ideal_mrd_near = window_coord_depth(far_dist) - window_coord_depth(*next_to_near); }
void render(int clientWidth, int clientHeight) { GLuint screenVao=geometryVaoManager->get(screenGeomFn,positionsVaoFn)->getVao(); GeometryDraw *screenDraw=geometryVaoManager->get(screenGeomFn,positionsVaoFn)->getDraw(); glViewport(0,0,clientWidth,clientHeight); //states glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glDisable(GL_BLEND); glDisable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); //bind fbo glBindFramebuffer(GL_DRAW_FRAMEBUFFER, deferredFbo); //clear glClearColor(0.0f,0.0f,0.0f,0.0f); glClearDepth(1); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //states glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE); //draw entity geom depths //states glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); //draw entity geoms { for(Mesh *m : scene->getMeshes()) { GLuint prog=0; if(m->material==Mesh::Color) { prog=programManager->get(geometryColoredProgFn); } else if(m->material==Mesh::Parallax) { prog=programManager->get(geometryParallaxProgFn); if(m->reliefTex.empty()) { prog=programManager->get("data/shader/geometry/Parallax2.json"); } else { prog=programManager->get("data/shader/geometry/Parallax.json"); } } if(GLuint tex=textureManager->get2d(m->colorTex)) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,tex); } if(GLuint tex=textureManager->get2d(m->normalTex)) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D,tex); // std::cout << "n " << tex << std::endl; } if(GLuint tex=textureManager->get2d(m->heightTex)) { glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D,tex); } if(GLuint tex=textureManager->get2d(m->reliefTex)) { glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D,tex); } // glUseProgram(prog); int modelViewProjMatLoc=glGetUniformLocation(prog,"u_modelViewProjMat"); int modelViewMatLoc=glGetUniformLocation(prog,"u_modelViewMat"); int normalMatLoc=glGetUniformLocation(prog,"u_normalMat"); int colLoc=glGetUniformLocation(prog,"u_col"); int shininessLoc=glGetUniformLocation(prog,"u_shininess"); int emissiveLoc=glGetUniformLocation(prog,"u_emissive"); int reflectiveLoc=glGetUniformLocation(prog,"u_reflective"); int bumpScaleLoc=glGetUniformLocation(prog,"u_bumpScale"); int bumpBiasLoc=glGetUniformLocation(prog,"u_bumpBias"); int reliefScaleLoc=glGetUniformLocation(prog,"u_reliefScale"); int parallaxScaleLoc=glGetUniformLocation(prog,"u_parallaxScale"); int parallaxBiasLoc=glGetUniformLocation(prog,"u_parallaxBias"); int parallaxInvertHeightLoc=glGetUniformLocation(prog,"u_parallaxInvertHeight"); int zNearFarLoc=glGetUniformLocation(prog,"u_zNearFar"); // if(colLoc!=-1) { glUniform3fv(colLoc,1,m->color); } glUniformMatrix4fv(modelViewProjMatLoc,1,GL_TRUE,m->modelViewProjMat); if(modelViewMatLoc!=-1) { glUniformMatrix4fv(modelViewMatLoc,1,GL_TRUE,m->modelViewMat); } if(normalMatLoc!=-1) { glUniformMatrix3fv(normalMatLoc,1,GL_TRUE,m->normalMat); } if(shininessLoc!=-1) { glUniform1fv(shininessLoc,1,&m->shininess); } if(emissiveLoc!=-1) { glUniform1i(emissiveLoc,m->emissive?1:0); } if(reflectiveLoc!=-1) { glUniform1fv(reflectiveLoc,1,&m->reflective); } // if(bumpScaleLoc!=-1) { glUniform1fv(bumpScaleLoc,1,&m->bumpScale); } if(bumpBiasLoc!=-1) { glUniform1fv(bumpBiasLoc,1,&m->bumpBias); } // if(reliefScaleLoc!=-1) { glUniform1fv(reliefScaleLoc,1,&m->reliefScale); } // if(parallaxScaleLoc!=-1) { glUniform1fv(parallaxScaleLoc,1,&m->parallaxScale); } if(parallaxBiasLoc!=-1) { glUniform1fv(parallaxBiasLoc,1,&m->parallaxBias); } if(parallaxInvertHeightLoc!=-1) { glUniform1i(parallaxInvertHeightLoc,m->parallaxInvertHeight?1:0); } if(zNearFarLoc!=-1) { float zNearFar[2]={m->zNear,m->zFar}; glUniform2fv(zNearFarLoc,1,zNearFar); } // if(GeometryVao *gv=geometryVaoManager->get(m->geometry,m->vao)) { glBindVertexArray(gv->getVao()); if(GeometryDraw *d=gv->getDraw(m->draw)) { d->draw(); } } } } //bind fbo glBindFramebuffer(GL_FRAMEBUFFER, 0); //bind textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, deferredColorTex); glBindSampler(0,0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, deferredNormalTex); glBindSampler(1,0); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, deferredDepthTex); glBindSampler(2,0); //states glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthFunc(GL_LESS); //clear glClearDepth(1.0f); glClear(GL_DEPTH_BUFFER_BIT); //render deferred depth texture glUseProgram(programManager->get(deferredDepthCopyProgFn)); glBindVertexArray(screenVao); screenDraw->draw(); //states glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_FALSE); //clear glClearColor(0.0f,0.0f,0.0f,1.0f); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); //bind vao glBindVertexArray(screenVao); //states glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); //draw point lights { GLuint p=programManager->get(deferredPointlightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightPosLoc=glGetUniformLocation(p,"u_lightPos"); GLint lightAttenLoc=glGetUniformLocation(p,"u_lightAtten"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); for(Pointlight *pl : scene->getPointlights()) { if(!pl->shadow) { glUniform4fv(lightPosLoc,1,pl->viewPos); glUniform3fv(lightAttenLoc,1,pl->attenuation); glUniform3fv(lightColLoc,1,pl->color); glUniform1fv(strengthLoc,1,&pl->strength); screenDraw->draw(); } } } //draw spot lights { GLuint p=programManager->get(deferredSpotlightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); for(Spotlight *sl : scene->getSpotlights()) { if(!sl->shadow) { } } } //draw directional lights { GLuint p=programManager->get(deferredDirectionallightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightDirLoc=glGetUniformLocation(p,"u_lightDir"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); for(Directionallight *dl : scene->getDirectionallights()) { if(!dl->shadow) { glUniform4fv(lightDirLoc,1,dl->viewDir); glUniform3fv(lightColLoc,1,dl->color); glUniform1fv(strengthLoc,1,&dl->strength); screenDraw->draw(); } } } //states glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); //draw point lights with shadows { // GLuint lightProg=programManager->get(deferredPointlightProgFn); GLuint invProjLoc=glGetUniformLocation(lightProg,"u_invProjMat"); GLint lightPosLoc=glGetUniformLocation(lightProg,"u_lightPos"); GLint lightAttenLoc=glGetUniformLocation(lightProg,"u_lightAtten"); GLint lightColLoc=glGetUniformLocation(lightProg,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(lightProg,"u_strength"); glUseProgram(lightProg); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(pointLightShadowGpuProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(pointLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightPosLoc2=glGetUniformLocation(shadowProg,"u_lightPos"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); // for(Pointlight *pl : scene->getPointlights()) { if(pl->shadow) { glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); glStencilFunc(GL_ALWAYS, 0, 0xff); //... bool lastZpass=false; glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.1f,1.0f); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //use shadow program glUseProgram(shadowProg); glUniform4fv(lightPosLoc2,1,pl->viewPos); // if(geometryShaderSupport && scene->isGeometryShadows()) { // glEnable(GL_PRIMITIVE_RESTART); for(Shadow *shadow : scene->getShadows()) { if(lastZpass !=shadow->zpass) { lastZpass=shadow->zpass; if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } } glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,pl,shadowCpuThreads,false); } } } } //draw light glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_CLAMP); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 0, 0xff); glUseProgram(lightProg); glUniform4fv(lightPosLoc,1,pl->viewPos); glUniform3fv(lightAttenLoc,1,pl->attenuation); glUniform3fv(lightColLoc,1,pl->color); glUniform1fv(strengthLoc,1,&pl->strength); glBindVertexArray(screenVao); screenDraw->draw(); } } //draw spot lights with shadows { } //draw directional lights with shadows //if(geometryShaderSupport && scene->isGeometryShadows()) //cpu directional shadows not implemented { GLuint p=programManager->get(deferredDirectionallightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightDirLoc=glGetUniformLocation(p,"u_lightDir"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(directionalLightShadowGpuProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(directionalLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightDirLoc2=glGetUniformLocation(shadowProg,"u_lightDir"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Directionallight *dl : scene->getDirectionallights()) { if(dl->shadow) { glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); glStencilFunc(GL_ALWAYS, 0, 0xff); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.3f,1.0f); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //use shadow program glUseProgram(shadowProg); glUniform4fv(lightDirLoc2,1,dl->viewDir); // if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,dl,shadowCpuThreads,false); } } } //draw light glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_CLAMP); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 0, 0xff); glUseProgram(p); glUniform4fv(lightDirLoc,1,dl->viewDir); glUniform3fv(lightColLoc,1,dl->color); glUniform1fv(strengthLoc,1,&dl->strength); glBindVertexArray(screenVao); screenDraw->draw(); } } } // glDisable(GL_STENCIL_TEST); //states glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); //bind vao glBindVertexArray(screenVao); //draw ambients { GLuint prog=programManager->get(deferredAmbientProgFn); GLuint ambienceLoc=glGetUniformLocation(prog,"u_ambience"); glUseProgram(prog); glUniform1f(ambienceLoc,0.05f); screenDraw->draw(); } //draw emissives glUseProgram(programManager->get(deferredEmissiveProgFn)); screenDraw->draw(); //bind sky texture to 3 glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_CUBE_MAP,textureManager->getCube(cubeEnvTexFn)); //states glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE); //draw reflections { GLuint prog=programManager->get(deferredReflectionProgFn); glUseProgram(prog); GLint invProjLoc=glGetUniformLocation(prog,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint viewLoc=glGetUniformLocation(prog,"u_invViewMat"); glUniformMatrix4fv(viewLoc,1,GL_TRUE,scene->getInvViewMat()); screenDraw->draw(); } //states glBlendFunc(GL_ONE, GL_ONE); //draw color test // glUseProgram(programManager->get("")); // screenDraw->draw(); //states glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); //clear stencil glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //stencil out sky area glUseProgram(programManager->get(deferredDepthStencilProg)); screenDraw->draw(); //states glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilFunc(GL_EQUAL, 0x0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); //draw sky { GLuint skyProg=programManager->get(skyboxProgFn); GeometryVao *gv=geometryVaoManager->get(skyboxGeomFn,positionsVaoFn); glUseProgram(skyProg); GLuint loc=glGetUniformLocation(skyProg,"u_viewRotProjMat"); glUniformMatrix4fv(loc,1,GL_TRUE,scene->getViewRotProjMat()); glBindVertexArray(gv->getVao()); gv->getDraw()->draw(); } //states glDisable(GL_STENCIL_TEST); glDisable(GL_CULL_FACE); glDisable(GL_BLEND); //glBlendEquation(GL_FUNC_ADD); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); //point light shadow debug if(scene->isShadowDebug()) { GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(pointLightShadowGpuDebugProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(pointLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightPosLoc2=glGetUniformLocation(shadowProg,"u_lightPos"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Pointlight *pl : scene->getPointlights()) { if(pl->shadow) { glUniform4fv(lightPosLoc2,1,pl->viewPos); if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(shadow->cpuShadow ) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,pl,shadowCpuThreads,true); } } } } } } //directional light shadow debug if(scene->isShadowDebug()) { // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(directionalLightShadowGpuDebugProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(directionalLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightDirLoc2=glGetUniformLocation(shadowProg,"u_lightDir"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Directionallight *dl : scene->getDirectionallights()) { if(dl->shadow) { //use shadow program glUniform4fv(lightDirLoc2,1,dl->viewDir); // if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,dl,shadowCpuThreads,true); } } } } } } //states glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_CLAMP); glDepthMask(GL_FALSE); //glDisable(GL_DEPTH_TEST); //glDepthFunc(GL_LESS); //draw normals, triangle normals, tangents, bitangents if(false && geometryShaderSupport) { GLuint prog=programManager->get(normalsDebugProgFn); glUseProgram(prog); int modelViewProjMatLoc=glGetUniformLocation(prog,"u_modelViewProjMat"); int modelViewMatLoc=glGetUniformLocation(prog,"u_modelViewMat"); int normalMatLoc=glGetUniformLocation(prog,"u_normalMat"); int projLoc=glGetUniformLocation(prog,"u_projMat"); if(projLoc!=-1) glUniformMatrix4fv(projLoc,1,GL_TRUE,scene->getProjMat() ); for(Mesh *m : scene->getMeshes()) { if(modelViewProjMatLoc!=-1) glUniformMatrix4fv(modelViewProjMatLoc,1,GL_TRUE,m->modelViewProjMat); if(normalMatLoc!=-1) glUniformMatrix4fv(normalMatLoc,1,GL_TRUE,m->normalMat); if(modelViewMatLoc!=-1) glUniformMatrix4fv(modelViewMatLoc,1,GL_TRUE,m->modelViewMat); if( m->material==Mesh::Normal || m->material==Mesh::Bump || m->material==Mesh::Parallax) { if(GeometryVao *gv=geometryVaoManager->get(m->geometry,m->vao)) { glBindVertexArray(gv->getVao()); if(GeometryDraw *d=gv->getDraw(m->draw)) { d->draw(); } } } } } }