C++ Fbo::unbindTexture方法代码示例

void Simulacra::helix()
{
    glDisable(GL_LIGHTING);
    glDisable(GL_LIGHT0);

    // render a simple scene into mFboScene
    helixShader.bind();
    gl::translate(0,0,0);
    helixFBO.bindFramebuffer();

    helixShader.uniform("time",Vec2f(sin(rotation),1-sin(rotation*0.71)));
    gl::clear(ColorA(0,0,0,1));
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    gl::drawSolidRect(cinder::Rectf(0,0,getWindowWidth(),getWindowHeight()));
    helixFBO.unbindFramebuffer();
    helixShader.unbind();

    //Revert back to screen
    gl::color(cinder::ColorA(1,1,1,1));
    applyHelixShader.bind();
    finalFBO.bindTexture(0);
    applyHelixShader.uniform("qt_Texture0",0);
    helixFBO.bindTexture(1);
    applyHelixShader.uniform("qt_Texture1",1);

    gl::drawSolidRect(cinder::Rectf(0,getWindowHeight(),getWindowWidth(),0));
    applyHelixShader.unbind();
    helixFBO.unbindTexture();
    finalFBO.unbindTexture();

    gl::color(ColorA(1,1,1,1));
}

void KinectEcard::renderSubstractedVideo(){
	mSubstractedVideoFbo.bindFramebuffer();

	gl::pushMatrices();
	{
		// clear FBO
		gl::clear( Color::black() );
		gl::color( Color::white() );

		//
		gl::setMatricesWindowPersp( mSubstractedVideoFbo.getSize() );

		mSubstractShader.bind();
		mSubstractShader.uniform( "tex0", 0 );
		mSubstractShader.uniform( "tex1", 1 );
		mSubstractShader.uniform( "tex2", 2 );
		mSubstractShader.uniform( "tex3", 3 );

		mVideoFbo.bindTexture(0);
		mDepthFbo.bindTexture(1);
		mStoredVideoFbo.bindTexture(2);
		mStoredDepthFbo.bindTexture(3);
		
		gl::drawSolidRect( mSubstractedVideoFbo.getBounds() );

		mVideoFbo.unbindTexture();
		mDepthFbo.unbindTexture();
		mStoredVideoFbo.unbindTexture();
		mStoredDepthFbo.unbindTexture();

		mSubstractShader.unbind();
	}
	gl::popMatrices();

	mSubstractedVideoFbo.unbindFramebuffer();
}

void ShadowMapSample::draw()
{
	gl::clear();
	gl::enableDepthWrite();
	glEnable( GL_LIGHTING );
	updateShadowMap();

	gl::enableDepthRead();

	glEnable( GL_TEXTURE_2D );
	mDepthFbo.bindDepthTexture();
	mShader.bind();
	mShader.uniform( "shadowTransMatrix", mLight->getShadowTransformationMatrix( *mCamera ) );
	
	if( mLookThroughCamera )
		gl::setMatrices( *mCamera );
	else
		gl::setMatrices( mLight->getShadowCamera() );
	mLight->update( *mCamera );

	glPushMatrix();
		mBackboard.draw();
		mTorus.draw();
		gl::drawCube( vec3::zero(), vec3( 1, 1, 1 ) );
	glPopMatrix();
	
	mShader.unbind();
	mDepthFbo.unbindTexture();
	
	// Draw the lighting frustum unless we're looking through it
	if( mLookThroughCamera ) {
		glDisable( GL_LIGHTING );
		glColor3f( 1.0f, 1.0f, 0.1f );
		gl::drawFrustum( mLight->getShadowCamera() );
	}
	
	if( mDrawDepthMap ) { // there are faster ways to achieve this, but this is a handy way to see the depth map
		gl::setMatricesWindow( getWindowSize() );
		Surface32f shadowMapSurface( mDepthFbo.getDepthTexture() );
		ip::hdrNormalize( &shadowMapSurface );
		gl::color( Color::white() );
		gl::draw( gl::Texture( shadowMapSurface ), Rectf( 0, 0, 128, 128 ) );
	}
}

void Grove::copyBlur(gl::Fbo& source, gl::Fbo& target, Vec2f sampleOffset)
{
	// bind the blur shader
	mBlurShader.bind();
	mBlurShader.uniform("tex0", 0); // use texture unit 0
	mBlurShader.uniform("sampleOffset", sampleOffset);

	// copy a horizontally blurred version of our scene into the first blur Fbo
	gl::setViewport( target.getBounds() );
	target.bindFramebuffer();
		source.bindTexture(0);
		gl::pushMatrices();
		gl::setMatricesWindow(target.getSize(), false);
			gl::clear( Color::black() );
			gl::drawSolidRect( target.getBounds() );
		gl::popMatrices();
		source.unbindTexture();
	target.unbindFramebuffer();	

	// unbind the shader
	mBlurShader.unbind();
}

void BloomingNeonApp::draw()
{
	// clear our window
	gl::clear( Color::black() );

	// store our viewport, so we can restore it later
	Area viewport = gl::getViewport();

	// render scene into mFboScene using illumination texture
	mTextureIllumination.enableAndBind();
	mTextureSpecular.bind(1);
	gl::setViewport( mFboScene.getBounds() );
	mFboScene.bindFramebuffer();
		gl::pushMatrices();
			gl::setMatricesWindow(SCENE_SIZE, SCENE_SIZE, false);
			gl::clear( Color::black() );
			render();
		gl::popMatrices();
	mFboScene.unbindFramebuffer();

	// bind the blur shader
	mShaderBlur.bind();
	mShaderBlur.uniform("tex0", 0); // use texture unit 0
 
	// tell the shader to blur horizontally and the size of 1 pixel
	mShaderBlur.uniform("sample_offset", Vec2f(1.0f/mFboBlur1.getWidth(), 0.0f));
	mShaderBlur.uniform("attenuation", 2.5f);

	// copy a horizontally blurred version of our scene into the first blur Fbo
	gl::setViewport( mFboBlur1.getBounds() );
	mFboBlur1.bindFramebuffer();
		mFboScene.bindTexture(0);
		gl::pushMatrices();
			gl::setMatricesWindow(BLUR_SIZE, BLUR_SIZE, false);
			gl::clear( Color::black() );
			gl::drawSolidRect( mFboBlur1.getBounds() );
		gl::popMatrices();
		mFboScene.unbindTexture();
	mFboBlur1.unbindFramebuffer();	
 
	// tell the shader to blur vertically and the size of 1 pixel
	mShaderBlur.uniform("sample_offset", Vec2f(0.0f, 1.0f/mFboBlur2.getHeight()));
	mShaderBlur.uniform("attenuation", 2.5f);

	// copy a vertically blurred version of our blurred scene into the second blur Fbo
	gl::setViewport( mFboBlur2.getBounds() );
	mFboBlur2.bindFramebuffer();
		mFboBlur1.bindTexture(0);
		gl::pushMatrices();
			gl::setMatricesWindow(BLUR_SIZE, BLUR_SIZE, false);
			gl::clear( Color::black() );
			gl::drawSolidRect( mFboBlur2.getBounds() );
		gl::popMatrices();
		mFboBlur1.unbindTexture();
	mFboBlur2.unbindFramebuffer();

	// unbind the shader
	mShaderBlur.unbind();

	// render scene into mFboScene using color texture
	mTextureColor.enableAndBind();
	mTextureSpecular.bind(1);
	gl::setViewport( mFboScene.getBounds() );
	mFboScene.bindFramebuffer();
		gl::pushMatrices();
			gl::setMatricesWindow(SCENE_SIZE, SCENE_SIZE, false);
			gl::clear( Color::black() );
			render();
		gl::popMatrices();
	mFboScene.unbindFramebuffer();

	// restore the viewport
	gl::setViewport( viewport );

	// because the Fbo's have their origin in the LOWER-left corner,
	// flip the Y-axis before drawing
	gl::pushModelView();
	gl::translate( Vec2f(0, 256) );
	gl::scale( Vec3f(1, -1, 1) );

	// draw the 3 Fbo's 
	gl::color( Color::white() );
	gl::draw( mFboScene.getTexture(), Rectf(0, 0, 256, 256) );
	drawStrokedRect( Rectf(0, 0, 256, 256) );

	gl::draw( mFboBlur1.getTexture(), Rectf(260, 0, 260 + 256, 256) );
	drawStrokedRect( Rectf(260, 0, 260 + 256, 256) );

	gl::draw( mFboBlur2.getTexture(), Rectf(520, 0, 520 + 256, 256) );
	drawStrokedRect( Rectf(520, 0, 520 + 256, 256) );

	// draw our scene with the blurred version added as a blend
	gl::color( Color::white() );
	gl::draw( mFboScene.getTexture(), Rectf(780, 0, 780 + 256, 256) );

	gl::enableAdditiveBlending();
	gl::draw( mFboBlur2.getTexture(), Rectf(780, 0, 780 + 256, 256) );
	gl::disableAlphaBlending();
	drawStrokedRect( Rectf(780, 0, 780 + 256, 256) );
	
//.........这里部分代码省略.........

void TextTestApp::draw()
{
	// this pair of lines is the standard way to clear the screen in OpenGL
	glClearColor( 0,0,0,1 );
	glClear( GL_COLOR_BUFFER_BIT );
	
	if (flipScreen==true){
		gl::pushMatrices();
		
		gl::scale( Vec3f(-1, 1, 1) );
		gl::translate( Vec2f(-ci::app::getWindowWidth(), 0 ) );
		gl::translate( Vec3f(-1, 1, 1) );
	}

	gl::enableAlphaBlending();
	gl::enableAdditiveBlending();

	mbackground.draw();

	drawSkeleton();

	// FONT NOW GETS RENDERED AFTER SCENE SO WE CAN OVERRIDE DRAW OPERATION IF REQUIRED
	currentScene->draw();

	myFont.draw();	
	
	// kill this all and refresh
	gl::disableAlphaBlending();
	gl::enableAdditiveBlending();

	// store our viewport, so we can restore it later
	Area viewport = gl::getViewport();

	// render a simple scene into mFboScene
	gl::setViewport( mFboScene.getBounds() );
	mFboScene.bindFramebuffer();
		gl::pushMatrices();
		gl::setMatricesWindow( viewport.getWidth(), viewport.getHeight(), false );
			gl::clear( ColorA( 0,0,0,1 ));
			fgParticles.draw();
			//gl::drawSolidCircle( Vec2f(50,50), 20 );
			//gl::draw( mFboScene.getTexture() );//TODO - screenshot?
		gl::popMatrices();
	mFboScene.unbindFramebuffer();

	// bind the blur shader
	mShaderBlur.bind();
	mShaderBlur.uniform("tex0", 0); // use texture unit 0
 
	// tell the shader to blur horizontally and the size of 1 pixel
	mShaderBlur.uniform("sampleOffset", Vec2f(1.0f/mFboBlur1.getWidth(), 0.0f));

	// copy a horizontally blurred version of our scene into the first blur Fbo
	
	gl::setViewport( mFboBlur1.getBounds() );
	mFboBlur1.bindFramebuffer();
		mFboScene.bindTexture(0);
		gl::pushMatrices();
			gl::setMatricesWindow( viewport.getWidth(), viewport.getHeight(), false );
			gl::clear( Color::black() );
			gl::drawSolidRect( mFboBlur1.getBounds() );
		gl::popMatrices();
		mFboScene.unbindTexture();
	mFboBlur1.unbindFramebuffer();

 
	// tell the shader to blur vertically and the size of 1 pixel
	mShaderBlur.uniform("sampleOffset", Vec2f(0.0f, 1.0f/mFboBlur2.getHeight()));

	// copy a vertically blurred version of our blurred scene into the second blur Fbo
	gl::setViewport( mFboBlur2.getBounds() );
	mFboBlur2.bindFramebuffer();
		mFboBlur1.bindTexture(0);
		gl::pushMatrices();
			gl::setMatricesWindow( viewport.getWidth(), viewport.getHeight(), false );
			gl::clear( Color::black() );
			gl::drawSolidRect( mFboBlur2.getBounds() );
		gl::popMatrices();
		mFboBlur1.unbindTexture();
	mFboBlur2.unbindFramebuffer();

	// unbind the shader
	mShaderBlur.unbind();

	// restore the viewport
	gl::setViewport( viewport );
	// because the Fbo's have their origin in the LOWER-left corner,
	// flip the Y-axis before drawing
	gl::pushModelView();
	gl::translate( Vec2f(0, 0 ) );// viewport.getHeight() ) );
	gl::scale( Vec3f(1, 1, 1) );

	// draw the 3 Fbo's 
	//gl::color( Color::white() );
	//gl::draw( mFboScene.getTexture(), Rectf(0, 0, 256, 256) );
	//gl::draw( mFboBlur1.getTexture(), Rectf(260, 0, 260 + 256, 256) );
	//gl::draw( mFboBlur2.getTexture(), Rectf(520, 0, 520 + 256, 256) );

	// draw our scene with the blurred version added as a blend
	gl::color( Color::white() );
//.........这里部分代码省略.........

//.........这里部分代码省略.........
        // disc
        if (zshift > 0){
            glPushMatrix();
            glTranslated( 640, 400, zshift - 200);
            if (shift2 && discOp > 1)
                glScalef(discOp, discOp, 0);
            //    cout << discOp << endl;
            mDisc.draw();
            glPopMatrix();
        }
        
        //cloud
        glPushMatrix();
        glTranslated( getWindowWidth() * 0.5f, getWindowHeight() * 0.5f, zshift );
        //    if (lightFade > .45f)
        mCloud.update(scaledX, scaledY, scaledZ, diamondFade, 1);
        glPopMatrix();
        
        if (drawDiamond){
            glPushMatrix();
            glTranslated( getWindowWidth() * 0.5f, getWindowHeight() * 0.5f, zshift);
            mDiamond.draw();
            glPopMatrix();
        }
    }
    
    // SECOND SCENE
    if (sceneTwo){
        
        mLight->lookAt( Vec3f(scaledX, scaledY, scaledZ +200), Vec3f (getWindowWidth()*.05, getWindowHeight() * 0.5f, 0.0f ));
        
        // cursor
        glPushMatrix();
        glTranslated( scaledX, scaledY, scaledZ );
        mCur.draw();
        
        if (scaledZ < 375 && scaledZ > 350)
            gl::drawSphere(Vec3f(0,0,0), (scaledZ-350)*.4);
        if (scaledZ >= 375)
            gl::drawSphere(Vec3f(0,0,0), 25*.4);
        glPopMatrix();
        
        
        // rotate whole scene; implement this later:
        
        //        if (targetFilled){
        //            glPushMatrix();
        //            glRotatef(getElapsedSeconds()*10, Vec3f (640, 400, 350) );
        //        }
        for (int i = 0; i < cubes.size() ; i++){
            glPushMatrix();
            glTranslatef(cubes[i].getLocation());
            cubes[i].update(.01f, screenCol);
            glPopMatrix();
        }
        offCounter = 0;        
        for (int i = 0; i < targets.size() ; i++){
            glPushMatrix();
            glTranslatef(targets[i].getLocation());
            targets[i].update(.01f, handPos, screenCol);
            if (targets[i].getBoxed() && targets[i].getBoxNumber() < 15 ){
                addCube(targets[i].getLocation().x, targets[i].getLocation().y, targets[i].getLocation().z);
                targets[i].addBox();
                if (targets[i].getBoxNumber() == 15)
                mAudio.playTraz("box");   
            }
            
            glPopMatrix();
            if (targets[i].getChargeSound()){
                if (!mAudio.isPlaying("charge")){
                    offCounter = 0;
                    mAudio.playTraz("charge");
                }
            }
            //stop charge if deactivated
            if (!targets[i].getChargeSound()){
                offCounter++;
            }
            if (offCounter == targets.size()){
                mAudio.stopTraz("charge");
            }
        }
        //  (from above)
        //   if (targetFilled)
        //   glPopMatrix();
        //
        
        //cloud
        glPushMatrix();
        glTranslated( getWindowWidth() * 0.5f, getWindowHeight() * 0.5f, zshift );
        mCloud.update(0, 0, 0, 0, 2);
        glPopMatrix();
    }
    
    mShader.unbind();
    mDepthFbo.unbindTexture();
    
    //    writeImage( getHomeDirectory() / ("image_" + toString( getElapsedFrames() ) + ".png"), copyWindowSurface() );
	
}

void SmoothDisplacementMappingApp::draw()
{
	gl::clear();

	// render background
	if( mBackgroundTexture && mBackgroundShader )
	{
		mBackgroundShader.bind();
		mBackgroundShader.uniform( "texture", 0 );
		mBackgroundShader.uniform( "hue", float( 0.025 * getElapsedSeconds() ) );
		gl::draw( mBackgroundTexture, getWindowBounds() );
		mBackgroundShader.unbind();
	}//*/

	// if enabled, show the displacement and normal maps 
	if(mDrawTextures) 
	{	
		gl::color( Color(0.05f, 0.05f, 0.05f) );
		gl::draw( mDispMapFbo.getTexture(), Vec2f(0,0) );
		gl::color( Color(1, 1, 1) );
		gl::draw( mNormalMapFbo.getTexture(), Vec2f(256,0) );
	}

	// setup the 3D camera
	gl::pushMatrices();
	gl::setMatrices( mCamera );

	// setup render states
	gl::enableAdditiveBlending();
	if(mDrawWireframe) 
		gl::enableWireframe();

	// draw undisplaced mesh if enabled
	if(mDrawOriginalMesh)
	{
		gl::color( ColorA(1, 1, 1, 0.2f) );
		gl::draw( mVboMesh );
	}

	if( mDispMapFbo && mNormalMapFbo && mMeshShader )
	{
		// bind the displacement and normal maps, each to their own texture unit
		mDispMapFbo.getTexture().bind(0);
		mNormalMapFbo.getTexture().bind(1);

		// render our mesh using vertex displacement
		mMeshShader.bind();
		mMeshShader.uniform( "displacement_map", 0 );
		mMeshShader.uniform( "normal_map", 1 );
		mMeshShader.uniform( "falloff_enabled", mEnableShader );

		gl::color( Color::white() );
		gl::draw( mVboMesh );

		mMeshShader.unbind();

		// unbind texture maps
		mNormalMapFbo.unbindTexture();
		mDispMapFbo.unbindTexture();
	}
	
	// clean up after ourselves
	gl::disableWireframe();
	gl::disableAlphaBlending();
	
	gl::popMatrices();//*/
}

void Simulacra::blur()
{
    //    glEnable( GL_TEXTURE_2D );
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    Area viewport = gl::getViewport();

    // render a simple scene into mFboScene
    gl::setViewport( sceneFBO.getBounds() );
    sceneFBO.bindFramebuffer();
    //        gl::pushMatrices();
    //            gl::setMatricesWindow(FBO_WIDTH, FBO_HEIGHT, false);
    gl::clear( ColorA(0,0,0,0) );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    gl::pushMatrices();
    gl::setMatrices(camera);
    try{
        //Draw points
        synthMenu->drawTerrain();
        synthMenu->drawSynths();
    } catch(...) {
        std::cout << "drawing error!" << std::endl;
    }
    gl::popMatrices();
    sceneFBO.unbindFramebuffer();


    // bind the blur shader
    blurShader.bind();
    blurShader.uniform("tex0", 0); // use texture unit 0

    // tell the shader to blur horizontally and the size of 1 pixel
    blurShader.uniform("sampleOffset", Vec2f(1.0f/blurFBO1.getWidth(), 0.0f));

    //FIRST PASS
    // copy a horizontally blurred version of our scene into the first blur Fbo
    gl::setViewport( blurFBO1.getBounds() );
    blurFBO1.bindFramebuffer();
    sceneFBO.bindTexture(0);
    gl::pushMatrices();
    gl::setMatricesWindow(FBO_WIDTH, FBO_HEIGHT, false);
    gl::clear( ColorA(0,0,0,0) );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glColor4f(1,1,1,1);
    gl::drawSolidRect( blurFBO1.getBounds() );
    gl::popMatrices();
    sceneFBO.unbindTexture();
    blurFBO1.unbindFramebuffer();

    // tell the shader to blur vertically and the size of 1 pixel
    blurShader.uniform("sampleOffset", Vec2f(0.0f, 1.0f/blurFBO2.getHeight()));

    // copy a vertically blurred version of our blurred scene into the second blur Fbo
    gl::setViewport( blurFBO2.getBounds() );
    blurFBO2.bindFramebuffer();
    blurFBO1.bindTexture(0);
    gl::pushMatrices();
    gl::setMatricesWindow(FBO_WIDTH, FBO_HEIGHT, false);
    gl::clear( ColorA(0,0,0,0) );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glColor4f(1,1,1,1);
    gl::drawSolidRect( blurFBO2.getBounds() );
    gl::popMatrices();
    blurFBO1.unbindTexture();
    blurFBO2.unbindFramebuffer();

    //SECOND PASS
    // copy a horizontally blurred version of our scene into the first blur Fbo
    blurShader.uniform("sampleOffset", Vec2f(1.0f/blurFBO1.getWidth(), 0.0f));
    gl::setViewport( blurFBO1.getBounds() );
    blurFBO1.bindFramebuffer();
    blurFBO2.bindTexture(0);
    gl::pushMatrices();
    gl::setMatricesWindow(FBO_WIDTH, FBO_HEIGHT, false);
    gl::clear( ColorA(0,0,0,0) );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glColor4f(1,1,1,1);
    gl::drawSolidRect( blurFBO1.getBounds() );
    gl::popMatrices();
    blurFBO2.unbindTexture();
    blurFBO1.unbindFramebuffer();

    // tell the shader to blur vertically and the size of 1 pixel
    blurShader.uniform("sampleOffset", Vec2f(0.0f, 1.0f/blurFBO2.getHeight()));

    // copy a vertically blurred version of our blurred scene into the second blur Fbo
    gl::setViewport( blurFBO2.getBounds() );
    blurFBO2.bindFramebuffer();
    blurFBO1.bindTexture(0);
    gl::pushMatrices();
    gl::setMatricesWindow(FBO_WIDTH, FBO_HEIGHT, false);
    gl::clear( ColorA(0,0,0,0) );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glColor4f(1,1,1,1);
    gl::drawSolidRect( blurFBO2.getBounds() );
    gl::popMatrices();
    blurFBO1.unbindTexture();
    blurFBO2.unbindFramebuffer();

    if(section == 1)
    {
//.........这里部分代码省略.........

//.........这里部分代码省略.........
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_INTERPOLATE);
    gl::draw(section3FBO.getTexture(),area);
    //    gl::pushMatrices();
    //    gl::setMatrices(camera);
    //    gl::pushMatrices();
    gl::disableDepthWrite();
    gl::disableDepthRead();
    gl::enableAlphaBlending();
    //    gl::clear(ColorA(0,0,0,0.01),true);
    //    if(bClear) {
    //    if(rand()%100>90) {
    //        bClear = false;
    //    }
    //    gl::clear(ColorA(0,0,0,0.0011));
    //    gl::translate(getWindowWidth()*0.4,0,0);
    //    gl::rotate(Vec3f(0,0,rotAmt*0.00004));
    //    gl::translate(getWindowWidth()*-0.4,0,0);
    //    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    /*
    } else {

        if(rand()%100>90) {
            gl::translate(getWindowWidth()*0.4,0,0);
//            gl::rotate(Vec3f(rotAmt*-0.15,0,rotAmt*-0.15));
            gl::rotate(Vec3f(0,0,rotAmt*0.00002));
            gl::translate(getWindowWidth()*-0.4,0,0);
            int z = (rand()%200)-100;

            glClear( GL_DEPTH_BUFFER_BIT );
            if(rand()%100>90) {
                bClear = true;
            }
        }
    }
    */
    //    gl::enableDepthWrite();
    //    gl::enableDepthRead();


    //Rotating Camera view
    //    gl::pushMatrices();
    //    gl::translate(0,0,-100);
    //    gl::translate(0,0,-getWindowHeight()*0.5);
    //    gl::rotate(Vec3f(0,rotAmt,0));
    //    gl::translate(0,0,getWindowHeight()*0.5);

    //Lighting
    gl::pushMatrices();
    gl::setMatrices(camera);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glShadeModel(GL_SMOOTH);

    //Light 1
    //    GLfloat light_position[] = {300*cos(rotation*0.05),300*sin(rotAmt*0.075),0,0.0};
    GLfloat light_position[4] = {0, 0, 0, 0};
    light_position[0] = 300*cos(rotation*0.05);
    light_position[1] = 300*sin(rotAmt*0.075);
    glLightfv( GL_LIGHT0, GL_POSITION, light_position );
    glLightf( GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.000000001f );
    glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.000000000f );
    glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.000000000f );
    //    GLfloat lightColor[] = {0.5f,0.9f,1,1};
    //    glLightfv( GL_LIGHT0,GL_DIFFUSE, lightColor);
    //    oscThread->drawSection2();

    glColor4f(0.7,0.7,0.7,(1.0));
    gl::disableDepthWrite();
    gl::disableDepthRead();
    gl::enableAlphaBlending();
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT);
    spheroid->draw();
    synthMenu->drawTerrain();
    gl::disableDepthWrite();
    gl::disableDepthRead();
    gl::enableAlphaBlending();
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    synthMenu->drawSynths();

    //    gl::popMatrices();
    section3FBO.unbindFramebuffer();
    gl::popMatrices();


    gl::clear(ColorA(0,0,0,1));
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    gl::enableDepthWrite();
    gl::enableDepthRead();
    gl::disableAlphaBlending();

    glDisable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
    //    glEnable(GL_TEXTURE_2D);
    //    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    gl::draw(section3FBO.getTexture(),getWindowBounds());
    sceneFBO.unbindTexture();
    synthMenu->drawTerrain();
}

void Simulacra::drawSection4()
{
    section3FBO.bindFramebuffer();
    gl::disableDepthWrite();
    gl::disableDepthRead();
    gl::enableAlphaBlending();
    gl::color(ColorA(0,0,0,0.01));
    glEnable(GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
    gl::drawSolidRect(
                Rectf(
                    cinder::app::getWindowBounds().getX1(),
                    cinder::app::getWindowBounds().getY1(),
                    cinder::app::getWindowBounds().getX2(),
                    cinder::app::getWindowBounds().getY2()
                    )
                );
    gl::enableAdditiveBlending();
    //    Area area = getWindowBounds();
    //    area.expand(1.1,1.1);
    //    gl::draw(section3FBO.getTexture(),area);
    //    gl::clear(ColorA(0,0,0,1));
    //    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );



    //Draw using Camera Perspective
    gl::pushMatrices();
    gl::setMatrices(camera);

    //Lighting
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glShadeModel(GL_SMOOTH);
    GLfloat light_position[] = {0,100,-100,0.5};
    glLightfv( GL_LIGHT0, GL_POSITION, light_position );
    glLightf( GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.00f );
    glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0000f );
    glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.00f );


    synthMenu->drawTerrain();
    glEnable(GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT);
    synthMenu->drawSynths();
    gl::popMatrices();
    //    blur();
    section3FBO.unbindFramebuffer();

    gl::clear(ColorA(0,0,0,1));
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    gl::enableDepthWrite();
    gl::enableDepthRead();
    gl::disableAlphaBlending();

    glDisable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

    gl::draw(section3FBO.getTexture(),getWindowBounds());
    sceneFBO.unbindTexture();
}

void FolApp::draw()
{
    gl::clear( Color::black() );

    if ( !mDepthTexture )
        return;

    // blur depth
    mDepthFbo.bindFramebuffer();
    gl::setMatricesWindow( mDepthFbo.getSize(), false );
    gl::setViewport( mDepthFbo.getBounds() );

    mBlurShader.bind();

    mBlurShader.uniform( "kernelSize", (float)mBlurKernelTexture.getWidth() );
    mBlurShader.uniform( "invKernelSize", 1.f / mBlurKernelTexture.getWidth() );
    mBlurShader.uniform( "imageTex", 0 );
    mBlurShader.uniform( "kernelTex", 1 );
    mBlurShader.uniform( "blurAmount", mBlurAmount );

    // pass 1
    glDrawBuffer( GL_COLOR_ATTACHMENT0_EXT );

    //gl::enable( GL_TEXTURE_2D );
    mDepthTexture.bind( 0 );
    mBlurKernelTexture.bind( 1 );
    mBlurShader.uniform( "stepVector", Vec2f( 1. / mDepthTexture.getWidth(), 0. ) );

    gl::drawSolidRect( mDepthFbo.getBounds() );

    mDepthTexture.unbind();

    // pass 2
    glDrawBuffer( GL_COLOR_ATTACHMENT1_EXT );

    mDepthFbo.bindTexture( 0 );
    mBlurShader.uniform( "stepVector", Vec2f( 0., 1. / mDepthFbo.getHeight() ) );
    gl::drawSolidRect( mDepthFbo.getBounds() );

    mDepthFbo.unbindTexture();
    mBlurKernelTexture.unbind();
    mBlurShader.unbind();

    mDepthFbo.unbindFramebuffer();

    // wave output
    mOutputFbo.bindFramebuffer();
    gl::setMatricesWindow( mOutputFbo.getSize(), false );
    gl::setViewport( mOutputFbo.getBounds() );

    gl::clear( Color::black() );
    gl::disableDepthRead();
    gl::disableDepthWrite();

    gl::enableAdditiveBlending();
    gl::color( ColorA( 1, 1, 1, .0195 ) );

    gl::pushMatrices();
    gl::scale( Vec2f( getWindowWidth() / (float)VBO_X_SIZE,
                      getWindowHeight() / (float)VBO_Y_SIZE) );

    mDepthFbo.getTexture( 1 ).bind();
    mWaveShader.bind();
    mWaveShader.uniform( "tex", 0 );
    mWaveShader.uniform( "invSize", Vec2f( mStep / mDepthFbo.getWidth(),
                                           mStep / mDepthFbo.getHeight() ) );
    mWaveShader.uniform( "clip", mClip );
    gl::draw( mVboMesh );
    mWaveShader.unbind();

    gl::popMatrices();

    gl::disableAlphaBlending();
    mOutputFbo.unbindFramebuffer();

    // bloom
    mBloomFbo.bindFramebuffer();

    gl::setMatricesWindow( mBloomFbo.getSize(), false );
    gl::setViewport( mBloomFbo.getBounds() );

    gl::color( Color::white() );
    mOutputFbo.getTexture().bind();

    mBloomShader.bind();
    for (int i = 0; i < 8; i++)
    {
        glDrawBuffer( GL_COLOR_ATTACHMENT0_EXT + i );
        mBloomShader.uniform( "iteration", i );
        gl::drawSolidRect( mBloomFbo.getBounds() );
        mBloomFbo.bindTexture( 0, i );
    }
    mBloomShader.unbind();

    glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
    mBloomFbo.unbindFramebuffer();

    // output mixer
    gl::setMatricesWindow( getWindowSize() );
    gl::setViewport( getWindowBounds() );
//.........这里部分代码省略.........