void MemExploreApp::draw() { mTexture = gl::Texture(mDataPointer, GL_RGBA, mVolumeDim * mTilesDim, mVolumeDim * mTilesDim); mTexture.setWrap(GL_REPEAT, GL_REPEAT); mTexture.setMinFilter(GL_NEAREST); mTexture.setMagFilter(GL_NEAREST); float frustum[6]; mCamera.getFrustum(&frustum[0], &frustum[1], &frustum[2], &frustum[3], &frustum[4], &frustum[5]); mFbo.bindFramebuffer(); gl::setMatricesWindow(mFbo.getSize(), false); mProgram.bind(); mProgram.uniform("uTexture", 0); mProgram.uniform("uVolumeDim", mVolumeDim); mProgram.uniform("uTilesDim", mTilesDim); mProgram.uniform("uTime", (float)getElapsedSeconds()); mProgram.uniform("uEyePoint", mCamera.getEyePoint()); mProgram.uniform("uXAxis", mCamera.getOrientation() * Vec3f::xAxis()); mProgram.uniform("uYAxis", mCamera.getOrientation() * Vec3f::yAxis()); mProgram.uniform("uViewDistance", mCamera.getAspectRatio() / abs(frustum[2] - frustum[0]) * mCamera.getNearClip()); mProgram.uniform("uNegViewDir", -mCamera.getViewDirection().normalized()); mProgram.uniform("uAspectRatio", mCamera.getAspectRatio()); mTexture.enableAndBind(); gl::drawSolidRect(mFbo.getBounds()); mTexture.unbind(); mProgram.unbind(); mFbo.unbindFramebuffer(); gl::setMatricesWindow(getWindowSize()); gl::draw(mFbo.getTexture(), getWindowBounds()); }
void RepulsionApp::setFboVelocities( gl::Fbo &fbo ) { Surface32f vel( fbo.getTexture() ); Surface32f::Iter it = vel.getIter(); while( it.line() ){ while( it.pixel() ){ Vec3f r = Rand::randVec3f() * 0.1f; it.r() = 0.0f;//r.x; it.g() = 0.0f;//r.y; it.b() = 0.0f;//r.z; it.a() = 0.0f; } } gl::Texture velTexture( vel ); velTexture.bind(); gl::setMatricesWindow( mFboSize, false ); gl::setViewport( mFboBounds ); fbo.bindFramebuffer(); mVelInitShader.bind(); mVelInitShader.uniform( "initTex", 0 ); gl::drawSolidRect( mFboBounds ); mVelInitShader.unbind(); fbo.unbindFramebuffer(); }
void BrainbowApp::updateShadowMap() { mDepthFbo.bindFramebuffer(); glPolygonOffset( 1.0f, 1.0f ); glEnable( GL_POLYGON_OFFSET_FILL ); glClear( GL_DEPTH_BUFFER_BIT ); glPushAttrib( GL_VIEWPORT_BIT ); glViewport( 0, 0, SHADOW_MAP_RESOLUTION, SHADOW_MAP_RESOLUTION ); gl::pushMatrices(); mLight->setShadowRenderMatrices(); mDisc.draw(); // mCyl.draw(); // mCur.draw(); mDiamond.draw(); gl::popMatrices(); glPopAttrib(); glDisable( GL_POLYGON_OFFSET_FILL ); mDepthFbo.unbindFramebuffer(); }
void PixarDemo2012::renderGradientFBO() { gl::enableAlphaBlending(); gl::SaveFramebufferBinding bindingSaver; mGradientFBO.bindFramebuffer(); gl::setViewport( mGradientFBO.getBounds() ); gl::setMatricesWindow( getWindowSize(), true ); gl::clear( ColorA(0.0f,0.0f,0.0f,1.0f) ); glDisable( GL_TEXTURE_2D ); // mGradientFBO.bindTexture(0); mGradientShader.bind(); float what = mTime; mGradientShader.uniform("mTime", what); mGradientShader.uniform("resolution", Vec2f((float)getWindowWidth(),(float)getWindowHeight())); gl::drawSolidRect( getWindowBounds() ); mGradientShader.unbind(); // mGradientFBO.unbindTexture(); gl::popMatrices(); }
void ShadedSphereApp::drawIntoRoomFbo() { mRoomFbo.bindFramebuffer(); gl::clear( ColorA( 0.0f, 0.0f, 0.0f, 0.0f ), true ); gl::setMatricesWindow( mRoomFbo.getSize(), false ); gl::setViewport( mRoomFbo.getBounds() ); gl::disableAlphaBlending(); gl::enable( GL_TEXTURE_2D ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); Matrix44f m; m.setToIdentity(); m.scale( mRoom.getDims() ); // mLightsTex.bind( 0 ); mRoomShader.bind(); mRoomShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mRoomShader.uniform( "mMatrix", m ); mRoomShader.uniform( "eyePos", mSpringCam.getEye() ); mRoomShader.uniform( "roomDims", mRoom.getDims() ); mRoomShader.uniform( "mainPower", mRoom.getPower() ); mRoomShader.uniform( "lightPower", mRoom.getLightPower() ); mRoom.draw(); mRoomShader.unbind(); mRoomFbo.unbindFramebuffer(); glDisable( GL_CULL_FACE ); }
// Render the torus into the FBO void FBOBasicApp::renderSceneToFbo() { // this will restore the old framebuffer binding when we leave this function // on non-OpenGL ES platforms, you can just call mFbo.unbindFramebuffer() at the end of the function // but this will restore the "screen" FBO on OpenGL ES, and does the right thing on both platforms gl::SaveFramebufferBinding bindingSaver; // bind the framebuffer - now everything we draw will go there mFbo.bindFramebuffer(); // setup the viewport to match the dimensions of the FBO gl::setViewport( mFbo.getBounds() ); // setup our camera to render the torus scene CameraPersp cam( mFbo.getWidth(), mFbo.getHeight(), 60.0f ); cam.setPerspective( 60, mFbo.getAspectRatio(), 1, 1000 ); cam.lookAt( Vec3f( 2.8f, 1.8f, -2.8f ), Vec3f::zero() ); gl::setMatrices( cam ); // set the modelview matrix to reflect our current rotation gl::multModelView( mTorusRotation ); // clear out the FBO with blue gl::clear( Color( 0.25, 0.5f, 1.0f ) ); // render an orange torus, with no textures glDisable( GL_TEXTURE_2D ); gl::color( Color( 1.0f, 0.5f, 0.25f ) ); gl::drawTorus( 1.4f, 0.3f, 32, 64 ); // gl::drawColorCube( Vec3f::zero(), Vec3f( 2.2f, 2.2f, 2.2f ) ); }
void SlytherinApp::update() { uint32_t elapsedFrames = getElapsedFrames(); bool needsFrame = mLastUpdateFrame == UINT32_MAX || (elapsedFrames - mLastUpdateFrame) * mLinesPerFrame >= 1.0f; if (mCapture && needsFrame && mCapture->checkNewFrame()) { uint32_t lineCount = (uint32_t)floorf((elapsedFrames - mLastUpdateFrame) * mLinesPerFrame); Surface8u surface = mCapture->getSurface(); Texture texture = Texture(surface); if (mLineIndex + lineCount < mFBO.getHeight()) { // single segment // mLineIndex to mLineIndex + lineCount console() << "process (" << mLineIndex << "-" << mLineIndex+lineCount << ") on frame " << elapsedFrames << endl; mLineIndex += lineCount; } else { // two segments // mLineIndex to mFBO.getHeight() - 1 uint32_t overflowLineCount = mLineIndex + lineCount - mFBO.getHeight() + 1; // 0 to overflowLineCount console() << "process (" << mLineIndex << "-" << mFBO.getHeight() - 1 << ") and (0-" << overflowLineCount << ") on frame " << elapsedFrames << endl; mLineIndex = overflowLineCount; } mLastUpdateFrame = elapsedFrames; } }
void KinectEcard::renderDepth(){ if( !mDepthSurface || !mVideoSurface ) return; gl::pushMatrices(); { mDepthFbo.bindFramebuffer(); // clear FBO gl::clear( Color::black() ); gl::color( Color::white() ); // gl::setMatricesWindowPersp( mDepthFbo.getSize() ); // draw depth gl::pushMatrices(); gl::scale( 2, 2 ); gl::draw( gl::Texture( mDepthSurface ) ); gl::popMatrices(); mDepthFbo.unbindFramebuffer(); } gl::popMatrices(); }
void SlytherinApp::setup() { // setup webcam try { mCapture = Capture::create(640, 480); mCapture->start(); } catch(...) { console() << "ERROR - failed to initialize capture" << endl; quit(); } // setup webcam FBO gl::Fbo::Format format; format.enableColorBuffer(true); format.enableDepthBuffer(false); format.setWrap(GL_CLAMP, GL_CLAMP); mFBO = gl::Fbo(mCapture->getWidth(), mCapture->getHeight(), format); mFBO.bindFramebuffer(); gl::setViewport(mFBO.getBounds()); gl::clear(); mFBO.unbindFramebuffer(); setFrameRate(60.0f); mLastUpdateFrame = UINT32_MAX; mLinesPerFrame = 2.0f; // 1 line every 2 frames (at getFrameRate()) mLineIndex = 0; }
void StereoscopicRenderingApp::renderInterlacedHorizontal( const Vec2i &size ) { // bind the FBO and clear its buffer mFbo.bindFramebuffer(); gl::clear( mColorBackground ); // render the scene using the over-under technique renderOverUnder( mFbo.getSize() ); // unbind the FBO mFbo.unbindFramebuffer(); // enable the interlace shader mShaderInterlaced.bind(); mShaderInterlaced.uniform( "tex0", 0 ); mShaderInterlaced.uniform( "window_origin", Vec2f( getWindowPos() ) ); mShaderInterlaced.uniform( "window_size", Vec2f( getWindowSize() ) ); // bind the FBO texture and draw a full screen rectangle, // which conveniently is exactly what the following line does gl::draw( mFbo.getTexture(), Rectf(0, float(size.y), float(size.x), 0) ); // disable the interlace shader mShaderInterlaced.unbind(); }
void LEDCamApp::draw() { // clear out the window with black gl::clear( kClearColor ); if( !mTexture ) return; mFbo.bindFramebuffer(); mTexture.enableAndBind(); mShader.bind(); float aspect = kWindowHeight/kWindowWidth; cout << "Aspect: " << aspect << " \n"; mShader.uniform( "aspect", aspect ); mShader.uniform( "tex", 0 ); mShader.uniform( "bright", 3.0f ); mShader.uniform( "spacing", 3 ); mShader.uniform( "ledCount", 100.0f ); gl::drawSolidRect( getWindowBounds() ); mTexture.unbind(); mShader.unbind(); mFbo.unbindFramebuffer(); gl::Texture fboTexture = mFbo.getTexture(); fboTexture.setFlipped(); gl::draw( fboTexture ); }
void FBOBasicApp::draw() { // clear the window to gray gl::clear( Color( 0.35f, 0.35f, 0.35f ) ); // setup our camera to render the cube CameraPersp cam( getWindowWidth(), getWindowHeight(), 60.0f ); cam.setPerspective( 60, getWindowAspectRatio(), 1, 1000 ); cam.lookAt( Vec3f( 2.6f, 1.6f, -2.6f ), Vec3f::zero() ); gl::setMatrices( cam ); // set the viewport to match our window gl::setViewport( getWindowBounds() ); // use the scene we rendered into the FBO as a texture glEnable( GL_TEXTURE_2D ); mFbo.bindTexture(); // draw a cube textured with the FBO gl::color( Color::white() ); gl::drawCube( Vec3f::zero(), Vec3f( 2.2f, 2.2f, 2.2f ) ); // show the FBO texture in the upper left corner gl::setMatricesWindow( getWindowSize() ); gl::draw( mFbo.getTexture(0), Rectf( 0, 0, 96, 96 ) ); #if ! defined( CINDER_GLES ) // OpenGL ES can't do depth textures, otherwise draw the FBO's gl::draw( mFbo.getDepthTexture(), Rectf( 96, 0, 96 + 96, 96 ) ); #endif }
void HiKinectApp::generateNormalMap() { // bind the Fbo mFbo.bindFramebuffer(); // match the viewport to the Fbo dimensions gl::setViewport( mFbo.getBounds() ); // setup an ortho projection gl::setMatricesWindow( mFbo.getWidth(), mFbo.getHeight() ); // clear the Fbo gl::clear( Color( 0, 0, 0 ) ); // bind the shader, set its variables mNormalShader.bind(); mNormalShader.uniform( "normalStrength", mNormalStrength); mNormalShader.uniform( "texelWidth", 1.0f / (float)CAPTURE_WIDTH ); if ( mDepthTexture ) { gl::pushModelView(); // gl::translate( Vec3f( 0, mDepthTexture.getHeight(), 0 ) ); // gl::scale( Vec3f( 1, -1, 1 ) ); gl::draw( mDepthTexture ); gl::popModelView(); } // unbind the shader mNormalShader.unbind(); // unbind the Fbo mFbo.unbindFramebuffer(); }
void ChargesApp::setup() { //gl::disableVerticalSync(); gl::Fbo::Format format; format.enableDepthBuffer( false ); format.setSamples( 4 ); mFbo = gl::Fbo( 1280, 800, format ); mKawaseBloom = mndl::gl::fx::KawaseBloom( mFbo.getWidth(), mFbo.getHeight() ); mEffectCharge.setup(); mEffectCharge.instantiate(); mEffectCharge.setBounds( mFbo.getBounds() ); // Leap mLeap = LeapSdk::Device::create(); mLeapCallbackId = mLeap->addCallback( &ChargesApp::onFrame, this ); // params mndl::kit::params::PInterfaceGl::load( "params.xml" ); mParams = mndl::kit::params::PInterfaceGl( "Parameters", Vec2i( 200, 300 ) ); mParams.addPersistentSizeAndPosition(); mParams.addParam( "Fps", &mFps, "", true ); mParams.addSeparator(); mParams.addPersistentParam( "Line width", &mLineWidth, 4.5f, "min=.5 max=10 step=.1" ); mParams.addPersistentParam( "Bloom strength", &mBloomStrength, .8f, "min=0 max=1 step=.05" ); mParams.addPersistentParam( "Finger disapperance thr", &mFingerDisapperanceThreshold, .1f, "min=0 max=2 step=.05" ); mndl::kit::params::PInterfaceGl::showAllParams( false ); }
void CatalogApp::setFboPositions( gl::Fbo &fbo ) { int numBrightStars = mBrightStars.size(); int index = 0; Surface32f posSurface( fbo.getTexture() ); Surface32f::Iter it = posSurface.getIter(); while( it.line() ){ while( it.pixel() ){ Vec3f pos = Vec3f( 1000000.0f, 0.0f, 0.0f ); float col = 0.4f; float rad = 0.0f; if( index < numBrightStars ){ pos = mBrightStars[index]->mPos; col = mBrightStars[index]->mColor; rad = floor( constrain( ( ( 6.0f - ( mBrightStars[index]->mAbsoluteMag ) )/6.0f ), 0.3f, 1.0f ) * 3.0f * 1000 ); } it.r() = pos.x; it.g() = pos.y; it.b() = pos.z; it.a() = rad + col; index ++; } } gl::Texture posTexture( posSurface ); fbo.bindFramebuffer(); gl::setMatricesWindow( fbo.getSize(), false ); gl::setViewport( fbo.getBounds() ); gl::clear( ColorA( 0, 0, 0, 0 ), true ); gl::draw( posTexture ); fbo.unbindFramebuffer(); }
void ShadowMapSample::updateShadowMap() { mDepthFbo.bindFramebuffer(); glPolygonOffset( 1.0f, 1.0f ); glEnable( GL_POLYGON_OFFSET_FILL ); glClear( GL_DEPTH_BUFFER_BIT ); glPushAttrib( GL_VIEWPORT_BIT ); glViewport( 0, 0, SHADOW_MAP_RESOLUTION, SHADOW_MAP_RESOLUTION ); gl::pushMatrices(); mLight->setShadowRenderMatrices(); mBackboard.draw(); mTorus.draw(); gl::drawCube( vec3::zero(), vec3( 1, 1, 1 ) ); gl::popMatrices(); glPopAttrib(); glDisable( GL_POLYGON_OFFSET_FILL ); mDepthFbo.unbindFramebuffer(); }
void BubbleChamberApp::drawIntoRoomFbo() { mRoomFbo.bindFramebuffer(); gl::clear( ColorA( 0.0f, 0.0f, 0.0f, 0.0f ), true ); gl::setMatricesWindow( mRoomFbo.getSize(), false ); gl::setViewport( mRoomFbo.getBounds() ); gl::disableAlphaBlending(); gl::enable( GL_TEXTURE_2D ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); Matrix44f m; m.setToIdentity(); m.scale( mRoom.getDims() ); mRoomShader.bind(); mRoomShader.uniform( "mvpMatrix", mActiveCam.mMvpMatrix ); mRoomShader.uniform( "mMatrix", m ); mRoomShader.uniform( "eyePos", mActiveCam.mCam.getEyePoint() ); mRoomShader.uniform( "roomDims", mRoom.getDims() ); mRoomShader.uniform( "power", mRoom.getPower() ); mRoomShader.uniform( "lightPower", mRoom.getLightPower() ); mRoomShader.uniform( "timePer", mRoom.getTimePer() * 1.5f + 0.5f ); mRoom.draw(); mRoomShader.unbind(); mRoomFbo.unbindFramebuffer(); glDisable( GL_CULL_FACE ); }
/* * @Description: render scene to FBO texture * @param: none * @return: none */ void Base_ThreeD_ProjectApp::renderSceneToFBO() { mScreenSpace1.bindFramebuffer(); glClearColor( 0.5f, 0.5f, 0.5f, 1 ); glClearDepth(1.0f); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); if (mLightingOn) glDisable(GL_LIGHTING); glColor3f( 1.0f, 1.0f, 0.1f ); gl::drawFrustum( mLightRef->getShadowCamera() ); glColor3f( 1.0f, 1.0f, 1.0f ); if (mLightingOn) glEnable(GL_LIGHTING); mEye = mCam->getEyePoint(); mEye.normalize(); mEye = mEye * abs(mCameraDistance); mCam->lookAt( mEye, mCenter, mUp ); gl::setMatrices( *mCam ); mLight->update( *mCam ); drawTestObjects(); mScreenSpace1.unbindFramebuffer(); glDisable(GL_LIGHTING); }
void SmoothDisplacementMappingApp::renderDisplacementMap() { if( mDispMapShader && mDispMapFbo ) { mDispMapFbo.bindFramebuffer(); { // clear the color buffer gl::clear(); // setup viewport and matrices glPushAttrib( GL_VIEWPORT_BIT ); gl::setViewport( mDispMapFbo.getBounds() ); gl::pushMatrices(); gl::setMatricesWindow( mDispMapFbo.getSize(), false ); // render the displacement map mDispMapShader.bind(); mDispMapShader.uniform( "time", float( getElapsedSeconds() ) ); mDispMapShader.uniform( "amplitude", mAmplitude ); gl::drawSolidRect( mDispMapFbo.getBounds() ); mDispMapShader.unbind(); // clean up after ourselves gl::popMatrices(); glPopAttrib(); } mDispMapFbo.unbindFramebuffer(); } }
void StereoscopicRenderingApp::renderAnaglyph( const Vec2i &size, const ColorA &left, const ColorA &right ) { // bind the FBO and clear its buffer mFbo.bindFramebuffer(); gl::clear( mColorBackground ); // render the scene using the side-by-side technique renderSideBySide( mFbo.getSize() ); // unbind the FBO mFbo.unbindFramebuffer(); // enable the anaglyph shader mShaderAnaglyph.bind(); mShaderAnaglyph.uniform( "tex0", 0 ); mShaderAnaglyph.uniform( "clr_left", left ); mShaderAnaglyph.uniform( "clr_right", right ); // bind the FBO texture and draw a full screen rectangle, // which conveniently is exactly what the following line does gl::draw( mFbo.getTexture(), Rectf(0, float(size.y), float(size.x), 0) ); // disable the anaglyph shader mShaderAnaglyph.unbind(); }
void ShaderToyApp::resize() { // Create/resize frame buffers (no multisampling) mBufferCurrent = gl::Fbo( getWindowWidth(), getWindowHeight() ); mBufferNext = gl::Fbo( getWindowWidth(), getWindowHeight() ); mBufferCurrent.getTexture().setFlipped(true); mBufferNext.getTexture().setFlipped(true); }
void KinectEcard::clear(){ mStoredDepthFbo.bindFramebuffer(); gl::clear( Color::white() ); mStoredDepthFbo.unbindFramebuffer(); mStoredVideoFbo.bindFramebuffer(); gl::clear( Color::white() ); mStoredVideoFbo.unbindFramebuffer(); }
void Narcotic::draw() { gl::clear(); fboProjection.bindFramebuffer(); gl::clear(Color::gray(0.25)); v1.draw(); fboProjection.unbindFramebuffer(); gl::draw(fboProjection.getTexture(), Rectf(projectionWindow->getBounds())); //fboProjection.unbindTexture(); }
void FBOMultipleTargetsApp::draw() { // clear the window to gray gl::clear( Color( 0.35f, 0.35f, 0.35f ) ); // set the viewport to match our window gl::setViewport( getWindowBounds() ); // draw the two textures we've created side-by-side gl::setMatricesWindow( getWindowSize() ); gl::draw( mFbo.getTexture(0), mFbo.getTexture(0).getBounds() ); gl::draw( mFbo.getTexture(1), mFbo.getTexture(1).getBounds() + Vec2f(mFbo.getTexture(0).getWidth(),0) ); }
void GroupingApp::draw() { float currTime = timer.getSeconds(); float deltaTime = currTime - prevTime; prevTime = currTime; if (autoRotation) { rotation += deltaTime * 60; rotation = fmod(rotation, 360); } fbo.bindFramebuffer(); gl::pushMatrices(); gl::clear(ColorA(0.2, 0.2, 0.2, 1.0)); gl::translate(Vec2f(getWindowWidth()/2, getWindowHeight()/2)); gl::rotate(rotation); gl::color(color); gl::enableAlphaBlending(); gl::disableDepthRead(); if (fill) { gl::translate(Vec2f(-50, -50)); gl::drawSolidRect(Rectf(-size/2, -size/2, size/2, size/2)); gl::translate(Vec2f(+100, +100)); gl::drawSolidRect(Rectf(-size/2, -size/2, size/2, size/2)); } else if (stroke) { glLineWidth(thickness); gl::translate(Vec2f(-50, -50)); gl::drawLine(Vec2f(-size/2, -size/2), Vec2f( size/2, -size/2)); gl::drawLine(Vec2f( size/2, -size/2), Vec2f( size/2, size/2)); gl::drawLine(Vec2f( size/2, size/2), Vec2f(-size/2, size/2)); gl::drawLine(Vec2f(-size/2, size/2), Vec2f(-size/2, -size/2)); gl::translate(Vec2f(+100, +100)); gl::drawLine(Vec2f(-size/2, -size/2), Vec2f( size/2, -size/2)); gl::drawLine(Vec2f( size/2, -size/2), Vec2f( size/2, size/2)); gl::drawLine(Vec2f( size/2, size/2), Vec2f(-size/2, size/2)); gl::drawLine(Vec2f(-size/2, size/2), Vec2f(-size/2, -size/2)); glLineWidth(1); } gl::popMatrices(); fbo.unbindFramebuffer(); gl::color(ColorA(1,1,1,1)); gl::draw(fbo.getTexture()); strokePanel->enabled = stroke ? true : false; gui->draw(); }
void BrainbowApp::initShadowMap() { mDepthFbo = gl::Fbo( SHADOW_MAP_RESOLUTION, SHADOW_MAP_RESOLUTION, false, false, true ); mDepthFbo.bindDepthTexture(); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); }
void GroupingApp::setup() { fbo = gl::Fbo(getWindowWidth(), getWindowHeight()); gui = new SimpleGUI(this, Font(loadResource(RES_SGUI_FONT), 8)); gui->lightColor = ColorA(1, 1, 0, 1); gui->addColumn(); gui->addLabel("CONTROLS"); gui->addParam("Rotation", &rotation, 0, 360, 0); gui->addParam("Size", &size, 100, 600, 200); gui->addParam("Color", &color, ColorA(0,0.5,1,0.5), SimpleGUI::RGB); //use R,G,B,A sliders gui->addColumn(); gui->addLabel("RENDER TYPE"); gui->addParam("Fill", &fill, true, RENDER_TYPE_GROUP); //if we specify group id, we create radio button set gui->addParam("Stroke", &stroke, false, RENDER_TYPE_GROUP); //i.e. only one of the buttons can be active at any time strokePanel = gui->addPanel(); gui->addParam("Thickness", &thickness, 1, 10); gui->addColumn(); gui->addLabel("OPTIONS"); gui->addParam("Auto Rotation", &autoRotation, false); gui->addColumn(); gui->addLabel("PREVIEW"); gui->addParam("PreviewTex", &fbo.getTexture()); gui->load(CONFIG_FILE); //we load settings after specifying all the //params because we need to know their name and type timer.start(); prevTime = timer.getSeconds(); }
void syphonImpApp::draw() { gl::enableAlphaBlending(); gl::clear( Color( 0.1f, 0.1f, 0.1f ) ); renderSceneToFbo(); mTextureSyphon.publishTexture(&myFbo.getTexture()); //publish our texture Vec2f upperLeftCorner = Vec2f( 0, WIDTH ); Vec2f lowerRightCorner = Vec2f(WIDTH,WIDTH-(WIDTH/1.33) ); Rectf rect = Rectf( upperLeftCorner, lowerRightCorner ); gl::draw( myFbo.getTexture(0),rect); }
void syphonImpApp::renderSceneToFbo() { // this will restore the old framebuffer binding when we leave this function // on non-OpenGL ES platforms, you can just call mFbo.unbindFramebuffer() at the end of the function // but this will restore the "screen" FBO on OpenGL ES, and does the right thing on both platforms gl::SaveFramebufferBinding bindingSaver; // bind the framebuffer - now everything we draw will go there myFbo.bindFramebuffer(); gl::setViewport(myFbo.getBounds() ); gl::setMatricesWindow( myFbo.getSize(), false ); // clear out the FBO with blue gl::clear(); mParticleController.update(); mParticleController.draw(); }
void ProjectionMappingApp::update() { this->updateBezierMesh();// update gl::setMatricesWindow(getWindowSize(), false); // 画像の表示を上向きにする mFbo.bindFramebuffer(); gl::clear(Color(0, 0, 0)); mShader.bind(); mShader.uniform("diffuseMap", 0); #if 0 mMovie.getTexture().bind(0); #else if (mEditMode == EditMode_EDIT) { if (mDispMode == DispMode_MOVIE && mHasMovie) { mMovie.getTexture().bind(0); } else { mDiffuseTex[mDispMode].bind(0); } } else if (mEditMode == EditMode_RECORD) { if (mFrame <= mDuration) { gl::Texture::Format texformat; texformat.setTargetRect(); std::string imgName = (boost::format("%s\\%s_%05d.png") % mInImageFolder % mInImageName % mFrame).str(); if (boost::filesystem::exists(boost::filesystem::path(imgName))) { mDiffuseTex[mDispMode] = gl::Texture(loadImage(imgName.c_str()), texformat); } else { mDispMode = DispMode_GUIDE; mEditMode = EditMode_EDIT; } } else { mEditMode = EditMode_EDIT; } } #endif gl::draw(mMesh); mShader.unbind(); mFbo.unbindFramebuffer(); }