/////////////////////////////////////////////////////////////////////////////// // Window has changed size, or has just been created. In either case, we need // to use the window dimensions to set the viewport and the projection matrix. void ChangeSize(int w, int h) { glViewport(0, 0, w, h); viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 500.0f); projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); modelViewMatrix.LoadIdentity(); }
/////////////////////////////////////////////////////////////////////////////// // This is called at least once and before any rendering occurs. If the screen // is a resizeable window, then this will also get called whenever the window // is resized. void ChangeSize(int nWidth, int nHeight) { glViewport(0, 0, nWidth, nHeight); transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix); viewFrustum.SetPerspective(35.0f, float(nWidth)/float(nHeight), 1.0f, 100.0f); projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); modelViewMatrix.LoadIdentity(); // update screen sizes screenWidth = nWidth; screenHeight = nHeight; // reset screen aligned quad gltGenerateOrtho2DMat(screenWidth, screenHeight, orthoMatrix, screenQuad); free(pixelData); pixelDataSize = screenWidth*screenHeight*3*sizeof(unsigned int); pixelData = (void*)malloc(pixelDataSize); // Resize PBOs #ifndef OPENGL_ES glBindBuffer(GL_PIXEL_PACK_BUFFER, pixBuffObjs[0]); glBufferData(GL_PIXEL_PACK_BUFFER, pixelDataSize, pixelData, GL_DYNAMIC_COPY); glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); #endif gltCheckErrors(); }
/////////////////////////////////////////////////////////////////////////////// // This is called at least once and before any rendering occurs. If the screen // is a resizeable window, then this will also get called whenever the window // is resized. void ChangeSize(int nWidth, int nHeight) { glViewport(0, 0, nWidth, nHeight); transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix); viewFrustum.SetPerspective(35.0f, float(nWidth)/float(nHeight), 1.0f, 100.0f); projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); modelViewMatrix.LoadIdentity(); // update screen sizes screenWidth = nWidth; screenHeight = nHeight; glBindRenderbuffer(GL_RENDERBUFFER, depthBufferName); #ifndef ANGLE glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32, screenWidth, screenHeight); #else glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, screenWidth, screenHeight); #endif glBindRenderbuffer(GL_RENDERBUFFER, renderBufferNames[0]); glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screenWidth, screenHeight); glBindRenderbuffer(GL_RENDERBUFFER, renderBufferNames[1]); glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screenWidth, screenHeight); glBindRenderbuffer(GL_RENDERBUFFER, renderBufferNames[2]); glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screenWidth, screenHeight); }
/** * @fn void ScreenRepaint::render(GLMatrixStack &modelViewStack, GLMatrixStack &projectionStack, * GLShaderManager &shaderManager); * * @brief Renders the quad. Note! THis should be called *after* all 3D drawing (i.e. after postDraw3D()), but *before* draw2D() * The steps are as follows: * First bind the PBO as the pack buffer, then read the pixels directly to the PBO and unbind * Next bind the PBO as the unpack buffer, then push the pixels straight into the texture * Setup texture unit for the render surface * switch to the GL_TEXTURE* value that we are using as our screen texture holder * write the pixels * unbind * Draw full screen quad with screen textures, calling setupScreenRenderProg() to access the chaders for the effect desired. * * * * @author Phil * @date 3/15/2012 * * @param [in,out] modelViewStack modelviewMatrix stack * @param [in,out] projectionStack projection matrix stack * @param [in,out] shaderManager Manager of default shaders */ void ScreenRepaint::render(GLMatrixStack &modelViewStack, GLMatrixStack &projectionStack, GLShaderManager &shaderManager){ // First bind the PBO as the pack buffer, then read the pixels directly to the PBO glBindBuffer(GL_PIXEL_PACK_BUFFER, pixBuffObjs[0]); // bind glReadPixels(0, 0, screenWidth, screenHeight, GL_RGB, GL_UNSIGNED_BYTE, NULL); // act glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); // unbind // Next bind the PBO as the unpack buffer, then push the pixels straight into the texture glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pixBuffObjs[0]); // bind // Setup texture unit for the render surface glActiveTexture(screenTextureID); // switch to the GL_TEXTURE* value that we are using as our screen texture holder glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); // write the pixels glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); // unbind // Draw full screen quad with screen textures projectionStack.PushMatrix(); projectionStack.LoadMatrix(orthoMatrix); modelViewStack.PushMatrix(); modelViewStack.LoadIdentity(); glDisable(GL_DEPTH_TEST); setupScreenRenderProg(projectionStack.GetMatrix()); screenQuad.Draw(); glEnable(GL_DEPTH_TEST); modelViewStack.PopMatrix(); projectionStack.PopMatrix(); }
void ChangeSize(int nWidth, int nHeight) { glViewport(0, 0, nWidth, nHeight); transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix); viewFrustum.SetPerspective(35.0f, float(nWidth)/float(nHeight), 1.0f, 100.0f); projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); modelViewMatrix.LoadIdentity(); }
void ChangeSize(int w, int h) { GLfloat nRange = 500.0f; windowWidth = w; windowHeight = h; // Verhindere eine Division durch Null if (h == 0) { h = 1; } // Setze den Viewport gemaess der Window-Groesse glViewport(0, 0, w, h); // Ruecksetzung des Projection matrix stack projectionMatrix.LoadIdentity(); if (bPerspectiveProj) { // Definiere das viewing volume (left, right, bottom, top, near, far) if (w <= h) { viewFrustum.SetPerspective(30.0f, h/w, 1, 3000); } else { viewFrustum.SetPerspective(30.0f, w / h, 1, 3000); } } else { // Definiere das viewing volume (left, right, bottom, top, near, far) if (w <= h) { viewFrustum.SetOrthographic(-nRange, nRange, -nRange*h / w, nRange*h / w, -nRange, nRange); } else { viewFrustum.SetOrthographic(-nRange*w / h, nRange*w / h, -nRange, nRange, -nRange, nRange); } } projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); // Ruecksetzung des Model view matrix stack modelViewMatrix.LoadIdentity(); TwWindowSize(w, h); }
void Reshape(int width,int height) { glViewport(0,0,width,height); transformPipeline.SetMatrixStacks(modelViewMatrix,projectionMatrix); viewFrustum.SetPerspective(35.0f,float(width)/float(height),1.0f,100.0f); projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); modelViewMatrix.LoadIdentity(); screenHeight = height; screenWidth = width; }
/////////////////////////////////////////////////////////////////////////////// // This is called at least once and before any rendering occurs. If the screen // is a resizeable window, then this will also get called whenever the window // is resized. void ChangeSize(int nWidth, int nHeight) { glViewport(0, 0, nWidth, nHeight); transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix); modelViewMatrix.LoadIdentity(); // update screen sizes screenWidth = nWidth; screenHeight = nHeight; GenerateOrtho2DMat(nWidth, nHeight, hdrTexturesWidth[curHDRTex], hdrTexturesHeight[curHDRTex]); }
void animate() { frameNo++; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glUseProgram(shader); //cameraAngleX += randf() * 5.0; //cameraAngleY += randf() * 2.7; //cameraAngleZ += randf() * 50.0; cameraBothZ += randf() * 10.0; matrixStack.LoadIdentity(); matrixStack.PushMatrix(); matrixStack.Scale(0.1,0.1,0.1); //Perspektywa + krêcenie kamery matrixStack.Rotate(40, 1, 0, 0); matrixStack.Rotate(cameraBothZ, 0, 0, 1); glUniformMatrix4fv(PMatrixLocation,1,GL_FALSE,matrixStack.GetMatrix()); float ambient[] = {0.5,0.2,0.2}, diffuse[] = {0.5,0.2,1}, specular[] = {0.2,1,0.2}; material.setMaterial(ambient, diffuse, specular, 1); float color[] = {1,1,1}, position[] = {0,0,-1}; light.setLight(position, color, 180, 1, 1, 2); float ambientLight[] = {1,1,1}; glUniform3fv(ambientLightLocation, 1, ambientLight); float small_color[] = {1,1,1}, small_position[] = {5 + 2*cos(frameNo/180.0*PI/2.0), 5 + 2*sin(frameNo/180.0*PI/2.0), -1}; small_light.setLight(small_position, small_color, 180, 1, 1, 2); matrixStack.PopMatrix(); //siatka pushSiatka(); float ambient2[] = {0.2,0.2,0.2}; material.setMaterial(ambient2, diffuse, specular, 1); RenderDwudziestoscian(5,5,-2,0.8); RenderDwudziestoscian(-5,-5,-2,0.5); RenderDwudziestoscian(small_position[0], small_position[1], small_position[2], 0.2); glutSwapBuffers(); }
/////////////////////////////////////////////////////////////////////////////// // This is called at least once and before any rendering occurs. If the screen // is a resizeable window, then this will also get called whenever the window // is resized. void ChangeSize(int nWidth, int nHeight) { glViewport(0, 0, nWidth, nHeight); transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix); viewFrustum.SetPerspective(35.0f, float(nWidth)/float(nHeight), 1.0f, 100.0f); projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix()); modelViewMatrix.LoadIdentity(); // update screen sizes screenWidth = nWidth; screenHeight = nHeight; glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, hdrTextures[0]); glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 8, GL_RGB16F, screenWidth, screenHeight, GL_FALSE); GenerateOrtho2DMat(nWidth, nHeight); glUseProgram(0); }
/////////////////////////////////////////////////////////////////////////////// // Render a frame. The owning framework is responsible for buffer swaps, // flushes, etc. void RenderScene(void) { static CStopWatch animationTimer; static float totalTime = 6; // To go back and forth static float halfTotalTime = totalTime/2; float seconds = animationTimer.GetElapsedSeconds() * speedFactor; float xPos = 0; // Calculate the next postion of the moving object // First perform a mod-like operation on the time as a float while(seconds > totalTime) seconds -= totalTime; // Move object position, if it's gone half way across // start bringing it back if(seconds < halfTotalTime) xPos = seconds -halfTotalTime*0.5f; else xPos = totalTime - seconds -halfTotalTime*0.5f; // First draw world to screen modelViewMatrix.PushMatrix(); M3DMatrix44f mCamera; cameraFrame.GetCameraMatrix(mCamera); modelViewMatrix.MultMatrix(mCamera); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE, transformPipeline.GetModelViewProjectionMatrix(), vWhite, 0); floorBatch.Draw(); DrawWorld(0.0f, xPos); modelViewMatrix.PopMatrix(); if(bUsePBOPath) { #ifndef OPENGL_ES // First bind the PBO as the pack buffer, then read the pixels directly to the PBO glBindBuffer(GL_PIXEL_PACK_BUFFER, pixBuffObjs[0]); glReadPixels(0, 0, screenWidth, screenHeight, GL_RGB, GL_UNSIGNED_BYTE, NULL); glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); // Next bind the PBO as the unpack buffer, then push the pixels straight into the texture glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pixBuffObjs[0]); // Setup texture unit for new blur, this gets imcremented every frame glActiveTexture(GL_TEXTURE0+GetBlurTarget0() ); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); #endif } else { // Grab the screen pixels and copy into local memory glReadPixels(0, 0, screenWidth, screenHeight, GL_RGB, GL_UNSIGNED_BYTE, pixelData); // Push pixels from client memory into texture // Setup texture unit for new blur, this gets imcremented every frame glActiveTexture(GL_TEXTURE0+GetBlurTarget0() ); #ifndef OPENGL_ES glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pixelData); #else glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pixelData); #endif } // Draw full screen quad with blur shader and all blur textures projectionMatrix.PushMatrix(); projectionMatrix.LoadIdentity(); projectionMatrix.LoadMatrix(orthoMatrix); modelViewMatrix.PushMatrix(); modelViewMatrix.LoadIdentity(); glDisable(GL_DEPTH_TEST); SetupBlurProg(); screenQuad.Draw(); glEnable(GL_DEPTH_TEST); modelViewMatrix.PopMatrix(); projectionMatrix.PopMatrix(); // Move to the next blur texture for the next frame AdvanceBlurTaget(); // Do the buffer Swap glutSwapBuffers(); // Do it again glutPostRedisplay(); UpdateFrameCount(); }
/////////////////////////////////////////////////////////////////////////////// // Render a frame. The owning framework is responsible for buffer swaps, // flushes, etc. void RenderScene(void) { // first render the scene in HDR to fbo glBindFramebuffer(GL_DRAW_FRAMEBUFFER, hdrFBO[0]); glDrawBuffers(1, &fboBuffs[0]); glClearColor(vSkyBlue[0], vSkyBlue[1], vSkyBlue[2], vSkyBlue[3]); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Draw to two textures, the first contains scene data // the second contains only the bright areas modelViewMatrix.PushMatrix(); M3DMatrix44f mCamera; cameraFrame.GetCameraMatrix(mCamera); modelViewMatrix.MultMatrix(mCamera); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textures[0]); // Marble // Draw the floor SetupTexReplaceProg(vLightPos, vWhite); floorBatch.Draw(); // Draw the window modelViewMatrix.PushMatrix(); modelViewMatrix.Translate(0.0f, -0.4f, -4.0f); modelViewMatrix.Rotate(10.0, 0.0, 1.0, 0.0); glBindTexture(GL_TEXTURE_2D, windowTexture); // Window Tex // First draw the window contents from texture SetupTexReplaceProg(vLightPos, vWhiteX2); windowBatch.Draw(); // Now draw the border and the grid SetupFlatColorProg(vLightPos, vLtGrey); windowGridBatch.Draw(); windowBorderBatch.Draw(); modelViewMatrix.PopMatrix(); modelViewMatrix.PopMatrix(); projectionMatrix.PushMatrix(); projectionMatrix.LoadMatrix(orthoMatrix); modelViewMatrix.PushMatrix(); modelViewMatrix.LoadIdentity(); // Combine original scene with blurred bright textures // to create the bloom effect glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glDrawBuffers(1,windowBuff); glViewport(0, 0, screenWidth, screenHeight); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); SetupHDRProg(); screenQuad.Draw(); modelViewMatrix.PopMatrix(); projectionMatrix.PopMatrix(); // Put the texture units back the way they were glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); // Do the buffer Swap glutSwapBuffers(); // Do it again glutPostRedisplay(); }
/////////////////////////////////////////////////////////////////////////////// // OpenGL related startup code is safe to put here. Load textures, etc. void SetupRC(void) { GLfloat texCoordOffsets[4][5*5*2]; GLfloat exposureLUT[20] = { 11.0, 6.0, 3.2, 2.8, 2.2, 1.90, 1.80, 1.80, 1.70, 1.70, 1.60, 1.60, 1.50, 1.50, 1.40, 1.40, 1.30, 1.20, 1.10, 1.00 }; // Make sure OpenGL entry points are set GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); } // Will not use depth buffer glDisable(GL_DEPTH_TEST); curHDRTex = 0; // Init codel-view and leave it modelViewMatrix.LoadIdentity(); // Black glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Setup LUT texture for use with the adaptive exposure filter glGenTextures(1, lutTxtures); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_1D, lutTxtures[1]); glTexImage1D(GL_TEXTURE_1D, 0, GL_R16F, 20, 0, GL_RED, GL_FLOAT, exposureLUT); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Setup HDR texture(s) glActiveTexture(GL_TEXTURE0); glGenTextures(1, hdrTextures); glBindTexture(GL_TEXTURE_2D, hdrTextures[curHDRTex]); // Load HDR image from EXR file LoadOpenEXRImage("Tree.exr", hdrTextures[curHDRTex], hdrTexturesWidth[curHDRTex], hdrTexturesHeight[curHDRTex]); // Create ortho matrix and screen-sized quad matching images aspect ratio GenerateOrtho2DMat(screenWidth, screenHeight, hdrTexturesWidth[curHDRTex], hdrTexturesHeight[curHDRTex]); //GenerateFBOOrtho2DMat(hdrTexturesWidth[curHDRTex], hdrTexturesHeight[curHDRTex]); gltGenerateOrtho2DMat(hdrTexturesWidth[curHDRTex], hdrTexturesHeight[curHDRTex], fboOrthoMatrix, fboQuad); // Setup tex coords to be used for fetching HDR kernel data for (int k = 0; k < 4; k++) { float xInc = 1.0f / (GLfloat)(hdrTexturesWidth[curHDRTex] >> k); float yInc = 1.0f / (GLfloat)(hdrTexturesHeight[curHDRTex] >> k); for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { texCoordOffsets[k][(((i*5)+j)*2)+0] = (-1.0f * xInc) + ((GLfloat)i * xInc); texCoordOffsets[k][(((i*5)+j)*2)+1] = (-1.0f * yInc) + ((GLfloat)j * yInc); } } } // Load shaders mapTexProg = gltLoadShaderPairWithAttributes("hdr.vs", "hdr_simple.fs", 2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_TEXTURE0, "vTexCoord0"); glBindFragDataLocation(mapTexProg, 0, "oColor"); glLinkProgram(mapTexProg); varExposureProg = gltLoadShaderPairWithAttributes("hdr.vs", "hdr_exposure_image.fs", 2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_TEXTURE0, "vTexCoord0"); glBindFragDataLocation(varExposureProg, 0, "oColor"); glLinkProgram(varExposureProg); glUseProgram(varExposureProg); glUniform1i(glGetUniformLocation(varExposureProg, "textureUnit0"), 0); adaptiveProg = gltLoadShaderPairWithAttributes("hdr.vs", "hdr_adaptive.fs", 2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_TEXTURE0, "vTexCoord0"); glBindFragDataLocation(adaptiveProg, 0, "oColor"); glLinkProgram(adaptiveProg); glUseProgram(adaptiveProg); glUniform1i(glGetUniformLocation(adaptiveProg, "textureUnit0"), 0); glUniform1i(glGetUniformLocation(adaptiveProg, "textureUnit1"), 1); glUniform2fv(glGetUniformLocation(adaptiveProg, "tc_offset"), 25, texCoordOffsets[0]); glUseProgram(0); // Create and bind an FBO glGenFramebuffers(1,&fboName); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboName); // Create the FBO texture glGenTextures(1, fboTextures); glBindTexture(GL_TEXTURE_2D, fboTextures[0]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, hdrTexturesWidth[curHDRTex], hdrTexturesHeight[curHDRTex], 0, GL_RGBA, GL_FLOAT, NULL); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fboTextures[0], 0); // Make sure all went well gltCheckErrors(); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); // Set first running mode curProg = adaptiveProg; }
/////////////////////////////////////////////////////////////////////////////// // Render a frame. The owning framework is responsible for buffer swaps, // flushes, etc. void RenderScene(void) { // Bind the FBO with multisample buffers glBindFramebuffer(GL_DRAW_FRAMEBUFFER, msFBO); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // User selected order independant transparency if (mode == USER_OIT) { // Use OIT, setup sample masks glSampleMaski(0, 0x01); glEnable(GL_SAMPLE_MASK); // Prevent depth test from culling covered surfaces glDepthFunc(GL_ALWAYS); } modelViewMatrix.PushMatrix(); M3DMatrix44f mCamera; cameraFrame.GetCameraMatrix(mCamera); modelViewMatrix.MultMatrix(mCamera); modelViewMatrix.PushMatrix(); modelViewMatrix.Translate(0.0f, -0.4f, -4.0f); modelViewMatrix.Rotate(worldAngle, 0.0, 1.0, 0.0); // Draw the background and disk to the first sample modelViewMatrix.PushMatrix(); modelViewMatrix.Translate(0.0f, 3.0f, 0.0f); modelViewMatrix.Rotate(90.0, 1.0, 0.0, 0.0); modelViewMatrix.Rotate(90.0, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, textures[1]); shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetModelViewProjectionMatrix(), 0); bckgrndCylBatch.Draw(); modelViewMatrix.PopMatrix(); modelViewMatrix.Translate(0.0f, -0.3f, 0.0f); modelViewMatrix.PushMatrix(); modelViewMatrix.Rotate(90.0, 1.0, 0.0, 0.0); shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGrey); diskBatch.Draw(); modelViewMatrix.PopMatrix(); modelViewMatrix.Translate(0.0f, 0.1f, 0.0f); // User selected blending if (mode == USER_BLEND) { // Setup blend state glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); switch (blendMode) { case 1: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; case 2: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA); break; case 3: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); break; case 4: glBlendFunc(GL_SRC_ALPHA, GL_ONE); break; case 5: glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR); break; case 6: glBlendFuncSeparate(GL_SRC_ALPHA, GL_DST_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; case 7: glBlendFuncSeparate(GL_SRC_COLOR, GL_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; default: glDisable(GL_BLEND); } } // Now draw the glass pieces DrawWorld(); modelViewMatrix.PopMatrix(); modelViewMatrix.PopMatrix(); // Clean up all state glDepthFunc(GL_LEQUAL); glDisable(GL_BLEND); glDisable(GL_SAMPLE_MASK); glSampleMaski(0, 0xffffffff); // Resolve multisample buffer projectionMatrix.PushMatrix(); projectionMatrix.LoadMatrix(orthoMatrix); modelViewMatrix.PushMatrix(); modelViewMatrix.LoadIdentity(); // Setup and Clear the default framebuffer glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glViewport(0, 0, screenWidth, screenHeight); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (mode == USER_OIT) SetupOITResolveProg(); else if (mode == USER_BLEND) SetupResolveProg(); // Draw a full-size quad to resolve the multisample surfaces screenQuad.Draw(); modelViewMatrix.PopMatrix(); projectionMatrix.PopMatrix(); // Reset texture state glEnable(GL_DEPTH_TEST); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); // Do the buffer Swap glutSwapBuffers(); // Do it again glutPostRedisplay(); }
void Gripper::environmentCalc(GLMatrixStack &modelViewStack, float phantomMat[16]){ phidgets.sampleAll(); for(int i = 0; i < 2; ++i){ if(phidgets.getRaw(i) > 500) return; if(phidgets.getRaw(i) < 0) return; } endEffector[RED].currentRaw = phidgets.getRaw(0); endEffector[GREEN].currentRaw = phidgets.getRaw(1); for(int i = 0; i < 2; ++i){ END_EFFECTOR *ee = &(endEffector[i]); ee->maxRaw = max(ee->maxRaw, ee->currentRaw); ee->minRaw = min(ee->minRaw, ee->currentRaw); double range = ee->maxRaw - ee->minRaw; double raw = ee->currentRaw - ee->minRaw; ee->gripperForce = max((1.0 - (raw/range)), 0); ee->curPos = ee->curPos - (ee->gripperForce - ee->restoreForce - ee->contactForce) * ee->scalar; ee->curPos = min(ee->maxRange, ee->curPos); ee->curPos = max(ee->minRange, ee->curPos); //Dprint::add("[%d] range = %.2f, raw = %.2f, maxRaw = %d, minRaw = %d, curPos = %.2f", i, range, raw, ee->maxRaw, ee->minRaw, ee->curPos); } modelViewStack.PushMatrix(); modelViewStack.LoadIdentity(); modelViewStack.MultMatrix(phantomMat); modelViewStack.Scale(scalar, scalar, scalar); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[YELLOW]); modelViewStack.PushMatrix(); modelViewStack.Translate(endEffector[RED].curPos, 0, 0.0); modelViewStack.Translate(0.0, 0, -8.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[RED]); modelViewStack.PushMatrix(); modelViewStack.Translate(0.0, 2.0, -2.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[RED2]); modelViewStack.Translate(0.0, -4.0, 0.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[RED3]); modelViewStack.Translate(0.0, 2.0, -2.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[RED4]); modelViewStack.PopMatrix(); modelViewStack.PopMatrix(); modelViewStack.PushMatrix(); modelViewStack.Translate(-endEffector[GREEN].curPos, 0, 0.0); modelViewStack.Translate(0.0, 0, -8.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[GREEN]); modelViewStack.PushMatrix(); modelViewStack.Translate(0.0, 2.0, -2.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[GREEN2]); modelViewStack.Translate(0.0, -4.0, 0.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[GREEN3]); modelViewStack.Translate(0.0, 2.0, -2.0); modelViewStack.GetMatrix(matrix); setPosFromMatrix(positions[GREEN4]); modelViewStack.PopMatrix(); modelViewStack.PopMatrix(); modelViewStack.PopMatrix(); for(int i = 0; i < NUM_END_EFFECTORS; ++i){ offsets[i][0] = positions[i][0] - positions[YELLOW][0]; offsets[i][1] = positions[i][1] - positions[YELLOW][1]; offsets[i][2] = positions[i][2] - positions[YELLOW][2]; } }