// Render the color cube 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::ScopedFramebuffer fbScp( mFbo );
// clear out the FBO with blue
gl::clear( Color( 0.25, 0.5f, 1.0f ) );
// setup the viewport to match the dimensions of the FBO
gl::ScopedViewport scpVp( ivec2( 0 ), mFbo->getSize() );
// 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( vec3( 2.8f, 1.8f, -2.8f ), vec3( 0 ));
gl::setMatrices( cam );
// set the modelview matrix to reflect our current rotation
gl::setModelMatrix( mRotation );
// render the color cube
gl::ScopedGlslProg shaderScp( gl::getStockShader( gl::ShaderDef().color() ) );
gl::color( Color( 1.0f, 0.5f, 0.25f ) );
gl::drawColorCube( vec3( 0 ), vec3( 2.2f ) );
gl::color( Color::white() );
}
void SMAA::apply( gl::FboRef destination, gl::FboRef source )
{
gl::ScopedFramebuffer fbo( destination );
gl::ScopedViewport viewport( 0, 0, destination->getWidth(), destination->getHeight() );
gl::ScopedMatrices matrices;
gl::setMatricesWindow( destination->getSize() );
// Make sure our source is linearly interpolated.
GLenum minFilter = source->getFormat().getColorTextureFormat().getMinFilter();
GLenum magFilter = source->getFormat().getColorTextureFormat().getMagFilter();
bool filterChanged = ( minFilter != GL_LINEAR || magFilter != GL_LINEAR );
if( filterChanged ) {
source->getColorTexture()->setMinFilter( GL_LINEAR );
source->getColorTexture()->setMagFilter( GL_LINEAR );
}
// Perform SMAA anti-aliasing.
gl::clear( ColorA( 0, 0, 0, 0 ) );
draw( source->getColorTexture(), destination->getBounds() );
// Restore texture parameters.
if( filterChanged ) {
source->getColorTexture()->setMinFilter( minFilter );
source->getColorTexture()->setMagFilter( magFilter );
}
}
void FaceOff::updateClone()
{
gl::ScopedMatrices mvp;
gl::setMatricesWindow(mRenderedOfflineFaceFbo->getSize());
gl::ScopedViewport viewport(0, 0, mRenderedOfflineFaceFbo->getWidth(), mRenderedOfflineFaceFbo->getHeight());
// TODO: merge these two passes w/ MRTs
{
gl::ScopedFramebuffer fbo(mRenderedOfflineFaceFbo);
gl::ScopedGlslProg glsl(gl::getStockShader(gl::ShaderDef().texture()));
gl::ScopedTextureBind t0(mOfflineFaceTex, 0);
gl::clear(ColorA::black(), false);
gl::draw(mFaceMesh);
}
if (!MOVIE_MODE)
{
{
gl::ScopedFramebuffer fbo(mFaceMaskFbo);
gl::clear(ColorA::black(), false);
gl::draw(mFaceMesh);
}
// TODO: add gl::ScopedMatrices in mClone.update()
mClone.update(mRenderedOfflineFaceFbo->getColorTexture(), mCapture.texture, mFaceMaskFbo->getColorTexture());
mHasNewRenderedFace = true;
}
}
// Render our scene into the FBO (a cube)
void FboMultipleRenderTargetsApp::renderSceneToFbo()
{
// setup our camera to render our scene
CameraPersp cam( mFbo->getWidth(), mFbo->getHeight(), 60 );
cam.setPerspective( 60, mFbo->getAspectRatio(), 1, 1000 );
cam.lookAt( vec3( 2.8f, 1.8f, -2.8f ), vec3( 0 ) );
// bind our framebuffer in a safe way:
gl::ScopedFramebuffer fboScope( mFbo );
// clear out both of the attachments of the FBO with black
gl::clear();
// setup the viewport to match the dimensions of the FBO, storing the previous state
gl::ScopedViewport viewportScope( ivec2( 0 ), mFbo->getSize() );
// store matrices before updating for CameraPersp
gl::ScopedMatrices matScope;
gl::setMatrices( cam );
// set the modelview matrix to reflect our current rotation
gl::multModelMatrix( mRotation );
// render the torus with our multiple-output shader
gl::ScopedGlslProg glslScope( mGlslMultipleOuts );
gl::drawCube( vec3( 0 ), vec3( 2.2f ) );
}
void ciApp::setup()
{
setWindowSize(1280, 720);
setFrameRate(60.f);
int maxVertUniformsVect;
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &maxVertUniformsVect);
mSize = 0;
mSizePrev = -1;
mSizeMax = 17;
mAmplifier = 1.f;
mExposure = 1.f;
mGamma = 2.2f;
printf("max uniform: %i, %i\n", maxVertUniformsVect, mSizeMax);
mParams = params::InterfaceGl::create(getWindow(), "App parameters", ivec2(250, 300));
mParams->setPosition(ivec2(20, 250));
mTexture = gl::Texture::create(loadImage(loadFile(data_path + "demo.png")));
mFbo = gl::Fbo::create(mTexture->getWidth(), mTexture->getHeight(), gl::Fbo::Format().colorTexture());
//mShader.setup("filterGaussianBlur");
filter = hb::GlslFilter::create(mTexture->getSize());
filter->setParams(mParams);
vector_blur.setup(getWindowSize());
vector_blur.setParams(mParams);
spout_receiver = hb::Receiver::create("Spout DX11 Sender");
//spout_receiver = hbSpoutReceiver::create("KidsLandSea");
spout_sender = hb::Sender::create("cinder_spout", mFbo->getWidth(), mFbo->getHeight());
#if 0
auto ctx = audio::Context::master();
// The InputDeviceNode is platform-specific, so you create it using a special method on the Context:
mInputDeviceNode = ctx->createInputDeviceNode();
// By providing an FFT size double that of the window size, we 'zero-pad' the analysis data, which gives
// an increase in resolution of the resulting spectrum data.
auto monitorFormat = audio::MonitorSpectralNode::Format().fftSize(2048).windowSize(1024);
mMonitorSpectralNode = ctx->makeNode(new audio::MonitorSpectralNode(monitorFormat));
mInputDeviceNode >> mMonitorSpectralNode;
// InputDeviceNode (and all InputNode subclasses) need to be enabled()'s to process audio. So does the Context:
mInputDeviceNode->enable();
ctx->enable();
#endif
}
void PostProcessingAAApp::render()
{
// Bind the Fbo. Automatically unbinds it at the end of this function.
gl::ScopedFramebuffer fbo( mFboScene );
// Clear the buffer.
gl::clear( ColorA( 0, 0, 0, 0 ) );
gl::color( Color::white() );
// Render our scene.
gl::pushViewport( 0, 0, mFboScene->getWidth(), mFboScene->getHeight() );
mPistons.draw( mCamera, float( mTime ) );
gl::popViewport();
}
void FXAA::apply( const gl::FboRef &destination, const gl::FboRef &source )
{
gl::ScopedFramebuffer fbo( destination );
gl::ScopedViewport viewport( 0, 0, destination->getWidth(), destination->getHeight() );
gl::ScopedMatrices matrices;
gl::setMatricesWindow( destination->getSize(), false );
// Make sure our source is linearly interpolated.
GLenum minFilter = source->getFormat().getColorTextureFormat().getMinFilter();
GLenum magFilter = source->getFormat().getColorTextureFormat().getMagFilter();
source->getColorTexture()->setMinFilter( GL_LINEAR );
source->getColorTexture()->setMagFilter( GL_LINEAR );
// Perform FXAA anti-aliasing.
gl::clear( ColorA( 0, 0, 0, 0 ) );
draw( source->getColorTexture(), destination->getBounds() );
// Restore texture parameters.
source->getColorTexture()->setMinFilter( minFilter );
source->getColorTexture()->setMagFilter( magFilter );
}
vec4 GpuParrallelReductionApp::findMindMax()
{
// init the programs, fbo and texture used for the parrallel reduction
static gl::FboRef sReductionFbo, sReadFbo;
static gl::Texture2dRef sReductionTexture0;
static gl::GlslProgRef sReductionProg, sCopyProg;
auto startingSize = mFbo->getSize() / 2;
if( !sReductionFbo || sReductionFbo->getSize() != startingSize ) {
sReductionTexture0 = gl::Texture2d::create( startingSize.x, startingSize.y, gl::Texture2d::Format().minFilter( GL_NEAREST_MIPMAP_NEAREST ).magFilter( GL_NEAREST ).mipmap().immutableStorage() );
sReductionFbo = gl::Fbo::create( startingSize.x, startingSize.y, gl::Fbo::Format()
.attachment( GL_COLOR_ATTACHMENT0, sReductionTexture0 )
.disableDepth() );
sReductionProg = gl::GlslProg::create( loadAsset( "minMax.vert" ), loadAsset( "minMax.frag" ) );
}
// start reduction profiling
static auto sTimer0 = gl::QueryTimeSwapped::create();
sTimer0->begin();
// attach the main level of the texture
gl::ScopedFramebuffer scopedFbo( sReductionFbo );
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sReductionTexture0->getId(), 0 );
// start by blitting the main fbo into the reduction one
mFbo->blitTo( sReductionFbo, mFbo->getBounds(), sReductionFbo->getBounds(), GL_NEAREST );
// bind the reduction program and texture and disable blending
gl::ScopedMatrices scopedMatrices;
gl::ScopedGlslProg scopedGlsl( sReductionProg );
gl::ScopedBlend scopedBlend( false );
gl::ScopedTextureBind scopedTexBind0( sReductionTexture0, 0 );
sReductionProg->uniform( "uTex0", 0 );
// iterate trough each mipmap level
int numMipMaps = gl::Texture2d::requiredMipLevels( startingSize.x, startingSize.y, 0 );
for( int level = 1; level < numMipMaps; ++level ) {
// attach the current mipmap level to the framebuffer and limit texture sampling to the previous level
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, level - 1 );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level - 1 );
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sReductionTexture0->getId(), level );
// get the current mipmap size and update uniforms
vec2 size = gl::Texture2d::calcMipLevelSize( level, sReductionFbo->getWidth(), sReductionFbo->getHeight() );
sReductionProg->uniform( "uInvSize", vec2( 1.0f ) / vec2( size ) );
// render a fullscreen quad
gl::ScopedViewport scopedViewport( ivec2( 0 ), size );
gl::setMatricesWindow( size.x, size.y );
gl::drawSolidRect( Rectf( vec2( 0.0f ), vec2( size ) ) );
}
// stop reduction profiling
sTimer0->end();
mReductionTime = sTimer0->getElapsedMilliseconds();
// start readback profiling
static auto sTimer1 = gl::QueryTimeSwapped::create();
sTimer1->begin();
// read back to the cpu and find the max value
vec4 max( 0.0f );
ivec2 readSize = gl::Texture2d::calcMipLevelSize( numMipMaps - 1, startingSize.x, startingSize.y );
Surface8u surface( readSize.x, readSize.y, true );
glGetTexImage( sReductionTexture0->getTarget(), numMipMaps - 1, GL_RGBA, GL_UNSIGNED_BYTE, surface.getData() );
auto it = surface.getIter();
while( it.line() ) { while( it.pixel() ) {
max = glm::max( max, vec4( it.r(), it.g(), it.b(), it.a() ) );
} }
// stop readback profiling
sTimer1->end();
mReadBackTime = sTimer1->getElapsedMilliseconds();
return max;
}
