void GLView::handleIdle() { modcounter++; if (!paused) world->update(); //show FPS int currentTime = glutGet( GLUT_ELAPSED_TIME ); frames++; if ((currentTime - lastUpdate) >= 1000) { std::pair<int,int> num_herbs_carns = world->numHerbCarnivores(); sprintf( buf, "FPS: %d NumAgents: %d Carnivors: %d Herbivors: %d Epoch: %d", frames, world->numAgents(), num_herbs_carns.second, num_herbs_carns.first, world->epoch() ); glutSetWindowTitle( buf ); frames = 0; lastUpdate = currentTime; } if (skipdraw<=0 && draw) { clock_t endwait; float mult=-0.005*(skipdraw-1); //ugly, ah well endwait = clock () + mult * CLOCKS_PER_SEC ; while (clock() < endwait) {} } if (draw) { if (skipdraw>0) { if (modcounter%skipdraw==0) renderScene(); //increase fps by skipping drawing } else renderScene(); //we will decrease fps by waiting using clocks } }
void display() { // Compute the MVP (Model View Projection matrix) glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); { glm::mat4 Projection = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / float(FRAMEBUFFER_SIZE.y), 0.1f, 100.0f); glm::mat4 MVP = Projection * View * Model; glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName); glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y); renderScene(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), MVP, Texture2DName); } { glm::mat4 Projection = glm::perspective(45.0f, float(Window.Size.x) / float(Window.Size.y), 0.1f, 100.0f); glm::mat4 MVP = Projection * View * Model; glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(0, 0, Window.Size.x, Window.Size.y); renderScene(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f), MVP, ColorbufferName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, ColorbufferName); glBindSampler(0, SamplerName); glGenerateMipmap(GL_TEXTURE_2D); } glf::checkError("display"); glf::swapBuffers(); }
void display() { // Compute the MVP (Model View Projection matrix) glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; glEnable(GL_SCISSOR_TEST); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glScissor(0, 0, Window.Size.x, Window.Size.y); glClear(GL_COLOR_BUFFER_BIT); glViewport(0, 0, Window.Size.x, Window.Size.y); renderScene(MVP); glClearColor(0.0f, 0.5f, 1.0f, 1.0f); glScissor(64, 48, 160, 120); glClear(GL_COLOR_BUFFER_BIT); glViewport(64, 48, 160, 120); renderScene(MVP); glDisable(GL_SCISSOR_TEST); glf::checkError("display"); glf::swapBuffers(); }
void GM_Debug::updateScene() { renderScene(); g_engine->resetClipping(); desktop.DelayedRemove(); if (killpopup) { delete popup; popup = NULL; killpopup = false; renderScene(); } }
void display() { glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glEnable(GL_SCISSOR_TEST); glDisable(GL_FRAMEBUFFER_SRGB); glScissorIndexed(0, 0, 0, Window.Size.x, Window.Size.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); { glm::mat4 Projection = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / float(FRAMEBUFFER_SIZE.y), 0.1f, 100.0f); glm::mat4 MVP = Projection * View * Model; glViewportIndexedf(0, 0, 0, float(FRAMEBUFFER_SIZE.x), float(FRAMEBUFFER_SIZE.y)); glDisable(GL_FRAMEBUFFER_SRGB); glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); renderScene(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), MVP, Texture2DName); glBindFramebuffer(GL_FRAMEBUFFER, 0); } { glm::mat4 Projection = glm::perspective(45.0f, float(Window.Size.x) / float(Window.Size.y), 0.1f, 100.0f); glm::mat4 MVP = Projection * View * Model; glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size.x, Window.Size.y)[0]); // Correct display glScissorIndexed(0, 0, Window.Size.y / 2 - 1, Window.Size.x, Window.Size.y / 2); glEnable(GL_FRAMEBUFFER_SRGB); glSamplerParameteri(SamplerName, GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT); // GL_DECODE_EXT renderScene(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f), MVP, ColorbufferName); glDisable(GL_FRAMEBUFFER_SRGB); // Incorrected display glScissorIndexed(0, 0, 0, Window.Size.x, Window.Size.y / 2); glEnable(GL_FRAMEBUFFER_SRGB); glSamplerParameteri(SamplerName, GL_TEXTURE_SRGB_DECODE_EXT, GL_DECODE_EXT); // GL_DECODE_EXT renderScene(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f), MVP, ColorbufferName); glDisable(GL_FRAMEBUFFER_SRGB); } glf::swapBuffers(); glf::checkError("display"); }
void display (void) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glDisable(GL_LIGHTING); drawAxis(); glEnable(GL_LIGHTING); glColor3f (1., 0, 0.); renderScene(); float ground[4] = {1,0,0,4}; myShadowMatrix(ground, position); glColor3f (0.5, 0.5, 0.5); renderScene(); glFlush (); }
/*Main Loop*/ void mainLoop() { double oldTime = glfwGetTime(), oldFrameTime = glfwGetTime(); double currentTime, deltaFrame; while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /*Delta*/ currentTime = glfwGetTime(); delta = (currentTime-oldTime); deltaFrame = (currentTime-oldFrameTime); nFrames++; /* Update scene elements */ world.update(); /*Draw*/ renderReflection(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderScene(true); world.camera.calcMovement(keyState); world.camera.move(delta, world.sea.seaLevel + 1.0f); glfwSwapBuffers(window); glfwPollEvents(); oldTime = currentTime; } }
void DS_Basic_MRT::buildGBuffers() { HRESULT hr; //-- G-Buffsers SetRenderTarget SRT(m_pD3DDevice, m_posRT); IDirect3DSurface9 *pSurfaceZ = NULL; hr = m_posRT_Z->GetSurfaceLevel(0, &pSurfaceZ ); IDirect3DSurface9 *pSurfaceNormal = NULL; hr = m_normalRT->GetSurfaceLevel(0, &pSurfaceNormal ); IDirect3DSurface9 *pSurfaceDiffuse= NULL; hr = m_diffuseRT->GetSurfaceLevel(0, &pSurfaceDiffuse ); hr = m_pD3DDevice->SetRenderTarget(1, pSurfaceZ); hr = m_pD3DDevice->SetRenderTarget(2, pSurfaceNormal); hr = m_pD3DDevice->SetRenderTarget(3, pSurfaceDiffuse); pSurfaceZ->Release(); pSurfaceDiffuse->Release(); pSurfaceNormal->Release(); hr = m_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1, 0); hr = m_pEffect->SetTechnique("init_mrt"); renderScene(); hr = m_pD3DDevice->SetRenderTarget(1, NULL); hr = m_pD3DDevice->SetRenderTarget(2, NULL); hr = m_pD3DDevice->SetRenderTarget(3, NULL); //hr = D3DXSaveTextureToFile("D:\\test.dds", D3DXIFF_DDS, m_posRT, NULL); }
void draw() { glClear(GL_COLOR_BUFFER_BIT); gl::MatrixStack & mv = gl::Stacks::modelview(); gl::MatrixStack & pr = gl::Stacks::projection(); FOR_EACH_EYE(eye) { const PerEyeArg & eyeArgs = eyes[eye]; frameBuffer.activate(); glEnable(GL_DEPTH_TEST); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gl::Stacks::with_push(pr, mv, [&]{ mv.preMultiply(eyeArgs.modelviewOffset); pr.preMultiply(eyeArgs.projectionOffset); renderScene(); }); frameBuffer.deactivate(); glDisable(GL_DEPTH_TEST); viewport(eye); distortProgram->use(); glActiveTexture(GL_TEXTURE1); eyeArgs.distortionTexture->bind(); glActiveTexture(GL_TEXTURE0); frameBuffer.color->bind(); quadGeometry->bindVertexArray(); quadGeometry->draw(); gl::VertexArray::unbind(); gl::Program::clear(); } }
void draw() { static int frameIndex = 0; static ovrPosef eyePoses[2]; ++frameIndex; ovrHmd_GetEyePoses(hmd, frameIndex, eyeOffsets, eyePoses, nullptr); ovrHmd_BeginFrame(hmd, frameIndex); glEnable(GL_DEPTH_TEST); for (int i = 0; i < 2; ++i) { ovrEyeType eye = hmd->EyeRenderOrder[i]; const ovrRecti & vp = textures[eye].Header.RenderViewport; eyeFramebuffers[eye]->Bind(); oglplus::Context::Viewport(vp.Pos.x, vp.Pos.y, vp.Size.w, vp.Size.h); Stacks::projection().top() = eyeProjections[eye]; MatrixStack & mv = Stacks::modelview(); mv.withPush([&]{ // Apply the per-eye offset & the head pose mv.top() = glm::inverse(ovr::toGlm(eyePoses[eye])) * mv.top(); renderScene(); }); }; oglplus::DefaultFramebuffer().Bind(oglplus::Framebuffer::Target::Draw); ovrHmd_EndFrame(hmd, eyePoses, textures); }
/*Setup a viewport of a first person view from a base.*/ void firstPersonView(float baseRotation, float starRotation, int leftY) { glPushMatrix(); glTranslatef(0.0, 0.0, -2.3); /*Rotate on x axis to get the flat ringworld.*/ glRotatef(-90.0, 1.0, 0.0, 0.0); /*Rotate on z to get to a base.*/ glRotatef(baseRotation, 0.0, 0.0, 1.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f, 700.0f/350.0f, 0.1f, 100.0f); glMatrixMode(GL_MODELVIEW); glViewport(0, leftY, 700, 350); /*Draw the star background perspective.*/ glPushMatrix(); glRotatef(starRotation, 0.0, 1.0, 0.0); glTranslatef(0.0, 0.0, -2.2); drawStarBackground(); glPopMatrix(); renderScene(); glPopMatrix(); }
MainWindow::MainWindow(QWidget *parent) : QWidget(parent) , m_rendererPanel(new RendererPanel(this)) { setlocale(LC_ALL,"C"); //omp_set_dynamic(1); display.resize(512,512); layout = new QHBoxLayout(); layout->addWidget(&display); layout->addWidget(m_rendererPanel); mainLayout = new QVBoxLayout(); renderButton = new QPushButton("Render"); mainLayout->addLayout(layout); mainLayout->addWidget(renderButton); setLayout(mainLayout); m_image = new Image(512, 512); display.setImage(m_image); connect(renderButton, SIGNAL(clicked()), this, SLOT(renderScene())); }
void Game::renderScreen() { m_currentCam->setAsCamera(); renderScene(false); PlaneObject *plane = objects->getPlaneObject(); if(plane != NULL) { //render plane reticles plane->renderReticle(15.0f, 1.3f); plane->renderReticle(8.0f, 1.0f); if (plane->isPlaneAlive() == false) { int textY = gRenderer.getScreenY()/2; IRectangle rect = IRectangle(0,textY,gRenderer.getScreenX()-1, textY + 30); gRenderer.drawText("Press \"Space Bar\" to Respawn",&rect, eTextAlignModeCenter, false); } } gConsole.render(); if (GameBase::m_renderInfo) GameBase::renderInfo(); }
//extern void update(); void update() { // add any update code here... // always re-render the scene.. renderScene(); }
void onDraw() { /*setViewer O(1)*/ setMatrixMode(PROJECTION); initMatrix(); setViewer(vertex(eyex, eyey, eyez), vertex(lookx, looky, lookz), vertex(upx, upy, upz)); setFrustum(10, 10*MAX_H/MAX_W, 4, 25); /*createPolygons O(1)*/ initScene(); setMatrixMode(MODELVIEW); initMatrix(); blockWithHole(-5.0,0.0,0.0); blockColoured(barx, bary, 0.0); /*calcData*/ /* For each polygon, Go to next triangle if current polygon doesn't face viewer O(1) Calculate pixel values of vertices of the triangle O(1) clip triangle //unless you model your scene such that no part ever goes outside the viewport (commentception) O(1) For each triangle, O(m*n) Add x,y,z position of scan conversion pixels to temp per-polygon table (indexed on y position with min and max x values) Also store a min and max x for y=0, y=MAX_Y-1. Add the x,y values for the points in between to the temp table Copy temp table to data table with the points between min and max x values filled (in case of conlict, min z value only) O(m*n) */ /*drawPixels*/ if(q4) innerclipTriangles(); renderScene(); glDrawPixels(MAX_W, MAX_H, GL_RGBA, GL_BYTE, data); glFlush(); }
void main() { glfwInit(); // Create a window window = glfwCreateWindow(800, 800, "Jarvis March", nullptr, nullptr); glfwMakeContextCurrent(window); glfwSwapInterval(0); // Initializes most things needed before the main loop init(); //Generate the point mesh Vertex pointVertex; pointVertex.x = pointVertex.y = pointVertex.z = pointVertex.r = 0.0f; pointVertex.g = pointVertex.b = pointVertex.a = 1.0f; //rope creation point = new struct Mesh(1, &pointVertex, GL_POINTS); //Scale the rope point->scale = glm::scale(point->scale, glm::vec3(1.0f)); //Generate 25 rigidbodies for(int i = 0; i < 25; i++) { float x = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX)) - 0.5f; float y = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX)) - 0.5f; bodies.push_back(RigidBody(glm::vec3(0.0f), glm::vec3(x, y, 0.0f))); } // Enter the main loop. while (!glfwWindowShouldClose(window)) { //Check time will update the programs clock and determine if & how many times the physics must be updated checkTime(); // Call the render function. renderScene(); // Swaps the back buffer to the front buffer // Remember, you're rendering to the back buffer, then once rendering is complete, you're moving the back buffer to the front so it can be displayed. glfwSwapBuffers(window); // Checks to see if any events are pending and then processes them. glfwPollEvents(); } // After the program is over, cleanup your data! glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(program); // Note: If at any point you stop using a "program" or shaders, you should free the data up then and there. delete point; // Frees up GLFW memory glfwTerminate(); }
// The main method. int main(int argc, char** argv) { const char* fileName = "Img"; // Print usage info. if (argc > 4) { printf("Usage: %s <optional: output> <optional: chunks chunknr> " "<optional: random seed>\n", argv[0]); exit(EXIT_FAILURE); } // Initialize the rand function. unsigned int seed = static_cast<unsigned int>(time(NULL)); if (argc > 1) { fileName = argv[1]; } size_t chunks = 1; size_t chunkNr = 0; if (argc > 3) { chunks = atol(argv[2]); chunkNr = atol(argv[3]); } if (argc == 5) { seed = static_cast<unsigned int>(atoi(argv[4])); } printf("Random seed used: %u\n\n", seed); srand(seed); // Render our test scene. renderScene(fileName, chunks, chunkNr); }
void View::mainLoop() { short continuer = 1; SDL_Event event; SDL_EnableKeyRepeat(40,40); SDL_WM_GrabInput(SDL_GRAB_ON); SDL_ShowCursor(SDL_DISABLE); while ( SDL_PollEvent(&event) ); // empty queue. int lastTime = SDL_GetTicks() - 30; int currentTime = 0; while (continuer) { lastTime = currentTime; currentTime = SDL_GetTicks(); while ( SDL_PollEvent(&event) ) { switch(event.type) { case SDL_QUIT: continuer = 0; break; case SDL_KEYDOWN: case SDL_KEYUP: camera.keyboard(event.key); break; case SDL_MOUSEMOTION: camera.mouseMotion(event.motion); break; default: break; } } renderScene(lastTime,currentTime); } SDL_Quit(); }
void updateGL() { //Done TODO: also clear the stencil buffer before rendering again // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // set viewport dimensions // glViewport(0, 0, windowWidth, windowHeight); // get projection mat from camera controller // glm_ProjectionMatrix.top() = camera.getProjectionMat(); // upload projection matrix // glUniformMatrix4fv(uniformLocations["projection"], 1, false, glm::value_ptr(glm_ProjectionMatrix.top())); // init scene graph by cloning the top entry, which can now be manipulated // // get modelview mat from camera controller // glm_ModelViewMatrix.top() = camera.getModelViewMat(); // #INFO# render scene // renderScene(); // #INFO# render shadow volume // renderShadow(); // swap renderbuffers for smooth rendering // glutSwapBuffers(); }
void render(void) { glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); renderScene(); glutSwapBuffers(); }
void GlutViewer::UpdateGeometry(PointCloudStorage* cloud) { if (cloud != NULL) this->cloud = cloud; renderScene(); }
void handleSelection(int x, int y) { glInitNames(); GLuint hitBuffer[64] = {0}; glSelectBuffer(64, hitBuffer); glRenderMode(GL_SELECT); GLint vp[4]; glGetIntegerv(GL_VIEWPORT,vp); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluPickMatrix(x,currentRes[1]-y,5.0,5.0,vp); gluPerspective(45.0,RESOLUTION_X/RESOLUTION_Y, 0.5, 50.0); glScalef((float)RESOLUTION_X/currentRes[0], (float)RESOLUTION_Y/currentRes[1], 1.0); glMatrixMode(GL_MODELVIEW); renderScene(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glFlush(); GLint hitCount = glRenderMode(GL_RENDER); listSelected(hitCount, hitBuffer); glMatrixMode(GL_MODELVIEW); }
void GLWidget::paintGL() { glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); if(withshadow){ glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT); glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO); glClear(GL_DEPTH_BUFFER_BIT); renderSceneShadow(); glBindFramebuffer(GL_FRAMEBUFFER, 0); // 2. Render scene as normal glViewport(0, 0, winWidth, winHeight); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, depthMap); renderSceneWithShadow(); }else{ renderScene(); } }
void display() { glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); // crtanje scene: renderScene(); glutSwapBuffers(); }
void draw() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gl::MatrixStack & mv = gl::Stacks::modelview(); gl::MatrixStack & pr = gl::Stacks::projection(); gl::Stacks::with_push(mv, pr, [&]{ renderScene(); }); }
void SceneRenderToTex::render() { glBindFramebuffer(GL_FRAMEBUFFER, fboHandle); renderToTexture(); glBindFramebuffer(GL_FRAMEBUFFER, 0); renderScene(); }
bool ClientEngine::onUpdate(double timeDelta) { m_Client.service(); if(!renderScene()) return false; m_ObjectManager.update(); return true; }
void Stage::renderDirectionalLightShadowMap(Light* light, Camera* shadowMapCamera) { if (light->shadow != Shadows::None) { DirectionalLight* dirLight = (DirectionalLight*) light; //directional light only needs one shadow map texture //light camera is supposed to be setup so that ortho frustum contains all that the main camera sees float quantizeFactor = 0; std::vector<glm::vec3> frustumCorners; if (dirLight->getShadowMethod() == DirectionalShadowMethods::Basic) { frustumCorners = m_camera->getFrustumCorners(); quantizeFactor = m_camera->getFar() * 0.3f; } else if (dirLight->getShadowMethod() == DirectionalShadowMethods::Near) { Camera newCamera; newCamera.initPerspective(m_camera->getFov(), m_camera->getAspectRatio(), m_camera->getNear(), m_camera->getFar() * dirLight->getShadowMethodValue()); newCamera.setTransform(m_camera->getTransform()); frustumCorners = newCamera.getFrustumCorners(); quantizeFactor = m_camera->getFar() * dirLight->getShadowMethodValue() * 0.3f; } glm::mat4 lightView = light->getTransform(); glm::mat4 invLightView = glm::inverse(lightView); for (int j = 0; j < 8; ++j) { frustumCorners[j] = glm::vec3(lightView * glm::vec4(frustumCorners[j], 1)); frustumCorners[j].x = glm::ceil(frustumCorners[j].x / quantizeFactor) * quantizeFactor; frustumCorners[j].y = glm::ceil(frustumCorners[j].y / quantizeFactor) * quantizeFactor; frustumCorners[j].z = glm::ceil(frustumCorners[j].z / quantizeFactor) * quantizeFactor; } BoundingBox lightBox(frustumCorners); lightBox.max.z += 100; lightBox.min.z -= 100; glm::vec3 boxSize = lightBox.max - lightBox.min; glm::vec3 halfBoxSize = boxSize * 0.5f; glm::vec3 lightPosition = lightBox.min + halfBoxSize; lightPosition.z = lightBox.min.z; lightPosition = glm::vec3(invLightView * glm::vec4(lightPosition, 1)); shadowMapCamera->lookAt(lightPosition, lightPosition + light->getForward(), light->getUp()); shadowMapCamera->setProjection(glm::ortho(-boxSize.x, boxSize.x, -boxSize.y, boxSize.y, -boxSize.z, boxSize.z)); ShaderProgram* depthShader = &m_allShaders.esmDepth; if (light->shadow == Shadows::VSM) { depthShader = &m_allShaders.vsmDepth; } m_shadowMap.bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); renderScene(depthShader, shadowMapCamera, light); m_shadowMap.unbind(); } }
void main() { glfwInit(); // Creates a window given (width, height, title, monitorPtr, windowPtr). // Don't worry about the last two, as they have to do with controlling which monitor to display on and having a reference to other windows. Leaving them as nullptr is fine. window = glfwCreateWindow(800, 800, "3D Sphere SAT (MTV and decoupling)", nullptr, nullptr); std::cout << "\n This program demonstrates the implementation SAT between two Spheres\n\n\n\n\n\n\n\n\n\n"; std::cout << "\n Press \" Space \" to toggle between the objects."; std::cout << "\n Use \"a,s,d\" to rotate the selected object."; std::cout << "\n Use \"i,j,k,l\" to move in XY plane"; std::cout << "\n Use \"u and o\" to move in Z axis"; // Makes the OpenGL context current for the created window. glfwMakeContextCurrent(window); // Sets the number of screen updates to wait before swapping the buffers. // Setting this to zero will disable VSync, which allows us to actually get a read on our FPS. Otherwise we'd be consistently getting 60FPS or lower, // since it would match our FPS to the screen refresh rate. // Set to 1 to enable VSync. glfwSwapInterval(0); // Initializes most things needed before the main loop init(); // Sends the funtion as a funtion pointer along with the window to which it should be applied to. glfwSetKeyCallback(window, key_callback); setup(); // Enter the main loop. while (!glfwWindowShouldClose(window)) { // Call to update() which will update the gameobjects. update(); // Call the render function. renderScene(); // Swaps the back buffer to the front buffer // Remember, you're rendering to the back buffer, then once rendering is complete, you're moving the back buffer to the front so it can be displayed. glfwSwapBuffers(window); // Checks to see if any events are pending and then processes them. glfwPollEvents(); } // After the program is over, cleanup your data! glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(program); // Note: If at any point you stop using a "program" or shaders, you should free the data up then and there. // Frees up GLFW memory glfwTerminate(); }
// Rotina Principal do programa int main(int argc, char **argv) { double start, finish; int i; if(argc != 2){ printf("Usage: %s <number of particles>\n",argv[0]); return 0; } // Recebe o número de partículas que devem ser processadas // e posteriormente renderizadas nParticulas = atoi(argv[1]); // Define a quantidade de partículas que não estão no chão (inicialmente nenhuma delas está) nParticulasAux = nParticulas; // Define posição inicial das particulas iniciarParticula(); // Funções necessárias para inicializar o OpenGL // e criar a janela que ficará renderizando glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100,100); glutInitWindowSize(640,640); glutCreateWindow("Trabalho Final - Computação Paralela"); glEnable(GL_DEPTH_TEST); // Inicializa a contagem do tempo GET_TIME(start); // Registrando CallBacks glutDisplayFunc(renderScene); glutReshapeFunc(changeSize); glutIdleFunc(renderScene); // Função que mantém o loop do evento de renderização // funcionado // Foi escolhido a função glutMainLoopEvent ao invés de glutMainLoop // pelo simples fato de que a segunda não pára até o programa finalizar // e a que escolhemos funciona como apenas uma iteração dessa função while(!Flag) { glutMainLoopEvent(); renderScene(); } // Finaliza o timer GET_TIME(finish); // Printa o tempo printf("Tempo gasto: %f\n", (finish - start)); free(vetor2); return 1; }