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 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 BloomingNeonApp::render()
{
// get the current viewport
Area viewport = gl::getViewport();
// adjust the aspect ratio of the camera
mCamera.setAspectRatio( viewport.getWidth() / (float) viewport.getHeight() );
// render our scene (see the Picking3D sample for more info)
gl::pushMatrices();
gl::setMatrices( mCamera );
gl::enableDepthRead();
gl::enableDepthWrite();
mShaderPhong.bind();
mShaderPhong.uniform("tex_diffuse", 0);
mShaderPhong.uniform("tex_specular", 1);
gl::pushModelView();
gl::multModelView( mTransform );
gl::color( Color::white() );
gl::draw( mMesh );
gl::popModelView();
mShaderPhong.unbind();
gl::disableDepthWrite();
gl::disableDepthRead();
gl::popMatrices();
}
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 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 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 AudioVisualizerApp::draw()
{
gl::clear();
// use camera
gl::pushMatrices();
gl::setMatrices(mCamera);
{
// bind shader
mShader.bind();
mShader.uniform("uTexOffset", mOffset / float(kHistory));
mShader.uniform("uLeftTex", 0);
mShader.uniform("uRightTex", 1);
// create textures from our channels and bind them
mTextureLeft = gl::Texture(mChannelLeft, mTextureFormat);
mTextureRight = gl::Texture(mChannelRight, mTextureFormat);
mTextureLeft.enableAndBind();
mTextureRight.bind(1);
// draw mesh using additive blending
gl::enableAdditiveBlending();
gl::color( Color(1, 1, 1) );
gl::draw( mMesh );
gl::disableAlphaBlending();
// unbind textures and shader
mTextureRight.unbind();
mTextureLeft.unbind();
mShader.unbind();
}
gl::popMatrices();
}
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 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();
}
/**
here's where the magic happens
all calculations are done in update
**/
void millionParticlesApp::update()
{
mFbo[mBufferIn].bindFramebuffer();
//set viewport to fbo size
gl::setMatricesWindow( mFbo[0].getSize(), false ); // false to prevent vertical flipping
gl::setViewport( mFbo[0].getBounds() );
GLenum buffer[3] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT };
glDrawBuffers(3,buffer);
mFbo[mBufferOut].bindTexture(0,0);
mFbo[mBufferOut].bindTexture(1,1);
mFbo[mBufferOut].bindTexture(2,2);
mVelTex.bind(3);
mPosTex.bind(4);
mNoiseTex.bind(5);
mVelShader.bind();
mVelShader.uniform("positions",0);
mVelShader.uniform("velocities",1);
mVelShader.uniform("information",2);
mVelShader.uniform("oVelocities",3);
mVelShader.uniform("oPositions",4);
mVelShader.uniform("noiseTex",5);
glBegin(GL_QUADS);
glTexCoord2f( 0.0f, 0.0f);
glVertex2f( 0.0f, 0.0f);
glTexCoord2f( 0.0f, 1.0f);
glVertex2f( 0.0f, PARTICLES);
glTexCoord2f( 1.0f, 1.0f);
glVertex2f( PARTICLES, PARTICLES);
glTexCoord2f( 1.0f, 0.0f);
glVertex2f( PARTICLES, 0.0f);
glEnd();
mVelShader.unbind();
mFbo[mBufferOut].unbindTexture();
mVelTex.unbind();
mPosTex.unbind();
mFbo[mBufferIn].unbindFramebuffer();
mBufferIn = (mBufferIn + 1) % 2;
mBufferOut = (mBufferIn + 1) % 2;
//for recording
// if (getElapsedFrames() == 600)
// exit(0);
}
void HexagonMirrorApp::draw()
{
// clear the window
gl::clear();
// activate our camera
gl::pushMatrices();
gl::setMatrices( mCamera.getCamera() );
// set render states
gl::enable( GL_CULL_FACE );
gl::enableDepthRead();
gl::enableDepthWrite();
gl::color( Color::white() );
if( mVboMesh && mShaderInstanced && mBuffer )
{
// bind webcam image
if( mWebcamTexture )
mWebcamTexture.bind(0);
// bind the shader, which will do all the hard work for us
mShaderInstanced.bind();
mShaderInstanced.uniform( "texture", 0 );
mShaderInstanced.uniform( "scale", Vec2f( 1.0f / (3.0f * INSTANCES_PER_ROW), 1.0f / (3.0f * INSTANCES_PER_ROW) ) );
// bind the buffer containing the model matrix for each instance,
// this will allow us to pass this information as a vertex shader attribute.
// See: initializeBuffer()
glBindVertexArray(mVAO);
// we do all positioning in the shader, and therefor we only need
// a single draw call to render all instances.
drawInstanced( mVboMesh, NUM_INSTANCES );
// make sure our VBO is no longer bound
mVboMesh.unbindBuffers();
// unbind vertex array object containing our buffer
glBindVertexArray(0);
// unbind shader
mShaderInstanced.unbind();
if( mWebcamTexture )
mWebcamTexture.unbind();
}
// reset render states
gl::disableDepthWrite();
gl::disableDepthRead();
gl::disable( GL_CULL_FACE );
// restore 2D drawing
gl::popMatrices();
}
void GeometryShaderApp::draw()
{
// clear out the window
gl::clear( Color(0.95f, 0.95f, 0.95f) );
// bind the shader and send the mesh to the GPU
if(mShader && mVboMesh) {
mShader.bind();
mShader.uniform( "WIN_SCALE", Vec2f( getWindowSize() ) ); // casting to Vec2f is mandatory!
mShader.uniform( "MITER_LIMIT", mLimit );
mShader.uniform( "THICKNESS", mThickness );
if(mTexture) {
gl::enableAlphaBlending();
gl::color( Color::white() );
mTexture.enableAndBind();
}
else
gl::color( Color::black() );
gl::draw( mVboMesh );
if(mTexture) {
mTexture.unbind();
gl::disableAlphaBlending();
}
if(mDrawWireframe) {
gl::color( Color::black() );
gl::enableWireframe();
gl::draw( mVboMesh );
gl::disableWireframe();
}
mShader.unbind();
}
// draw all points as red circles
gl::color( Color(1, 0, 0) );
std::vector<Vec2f>::const_iterator itr;
for(itr=mPoints.begin();itr!=mPoints.end();++itr)
gl::drawSolidCircle( *itr, mRadius );
if( ! mPoints.empty() )
gl::drawStrokedCircle( mPoints.back(), mRadius + 2.0f );
// draw help
if(mHelpTexture) {
gl::color( Color::white() );
gl::enableAlphaBlending();
gl::draw( mHelpTexture );
gl::disableAlphaBlending();
}
}
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());
}
/**
the draw method displays the last filled buffer
**/
void millionParticlesApp::draw()
{
gl::setMatricesWindow( getWindowSize() );
gl::setViewport( getWindowBounds() );
gl::clear( ColorA( 0.0f, 0.0f, 0.0f, 1.0f ) );
gl::enableAlphaBlending();
glDisable(GL_DEPTH_TEST);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
mFbo[mBufferIn].bindTexture(0,0);
mFbo[mBufferIn].bindTexture(1,1);
mFbo[mBufferIn].bindTexture(2,2);
mSpriteTex.bind(3);
//Bewegungsshader
mPosShader.bind();
mPosShader.uniform("posTex",0);
mPosShader.uniform("velTex",1);
mPosShader.uniform("infTex",2);
mPosShader.uniform("spriteTex",3);
mPosShader.uniform("scale",(float)PARTICLES);
gl::color(ColorA(1.0f,1.0f,1.0f,1.0f));
//glTranslatef(Vec3f(getWindowWidth() / 4 - PARTICLES,0.0f,0.0f));
gl::pushMatrices();
glScalef(getWindowHeight() / (float)PARTICLES , getWindowHeight() / (float)PARTICLES ,1.0f);
// draw particles
gl::draw( mVbo );
gl::popMatrices();
mPosShader.unbind();
mSpriteTex.unbind();
mFbo[mBufferIn].unbindTexture();
// writeImage( "/Users/hacku/Desktop/img/1m/" + toString(getElapsedFrames()) + ".tif", copyWindowSurface() );
// gl::color(Color(1,1,1));
// gl::setMatricesWindow( getWindowSize() );
//drawText();
gl::disableAlphaBlending();
}
/*
* @Description: render SSAO now - woohoo!
* @param: KeyEvent
* @return: none
*/
void Base_ThreeD_ProjectApp::renderSSAOToFBO()
{
gl::setViewport( mSSAOMap.getBounds() );
//render out main scene to FBO
mSSAOMap.bindFramebuffer();
glClearColor( 0.5f, 0.5f, 0.5f, 1 );
glClearDepth(1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
gl::setMatricesWindow( mSSAOMap.getSize() );
mRandomNoise.bind(1);
mNormalDepthMap.getTexture().bind(2);
mSSAOShader.bind();
mSSAOShader.uniform("rnm", 1 );
mSSAOShader.uniform("normalMap", 2 );
//look at shader and see you can set these through the client if you so desire.
// mSSAOShader.uniform("rnm", 1 );
// mSSAOShader.uniform("normalMap", 2 );
// mSSAOShader.uniform("totStrength", 1.38f);
// mSSAOShader.uniform("strength", 0.07f);
// mSSAOShader.uniform("offset", 10.0f);
// mSSAOShader.uniform("falloff", 0.2f);
// mSSAOShader.uniform("rad", 0.8f);
// mSSAOShader.uniform("rnm", 1 );
// mSSAOShader.uniform("normalMap", 2 );
// mSSAOShader.uniform("farClipDist", 20.0f);
// mSSAOShader.uniform("screenSizeWidth", (float)getWindowWidth());
// mSSAOShader.uniform("screenSizeHeight", (float)getWindowHeight());
// mSSAOShader.uniform("grandom", 1 );
// mSSAOShader.uniform("gnormals", 2 );
// mSSAOShader.uniform("gdepth", 1 );
// mSSAOShader.uniform("gdiffuse", 1 );
gl::drawSolidRect( Rectf( 0, 0, getWindowWidth(), getWindowHeight()) );
mSSAOShader.unbind();
mNormalDepthMap.getTexture().unbind(2);
mRandomNoise.unbind(1);
mSSAOMap.unbindFramebuffer();
gl::setViewport( getWindowBounds() );
}
void MandelbrotGLSLApp::draw()
{
gl::clear( Color( 0.2f, 0.2f, 0.2f ) );
gl::setMatricesWindow( getWindowSize() );
mBrotShader.bind();
mBrotShader.uniform( "tex", 0 );
mBrotShader.uniform( "center", mCenter );
mBrotShader.uniform( "scale", mScale );
mBrotShader.uniform( "iter", mIter );
gl::drawSolidRect( getWindowBounds() );
mBrotShader.unbind();
}
void RepulsionApp::drawIntoVelocityFbo()
{
gl::setMatricesWindow( mFboSize, false );
gl::setViewport( mFboBounds );
gl::disableAlphaBlending();
mVelocityFbos[ mThisFbo ].bindFramebuffer();
gl::clear( ColorA( 0, 0, 0, 0 ) );
mPositionFbos[ mPrevFbo ].bindTexture( 0 );
mVelocityFbos[ mPrevFbo ].bindTexture( 1 );
mVelocityShader.bind();
mVelocityShader.uniform( "position", 0 );
mVelocityShader.uniform( "velocity", 1 );
mVelocityShader.uniform( "roomBounds", mRoom.getDims() );
mVelocityShader.uniform( "w", FBO_WIDTH );
mVelocityShader.uniform( "h", FBO_HEIGHT );
mVelocityShader.uniform( "invWidth", 1.0f/(float)FBO_WIDTH );
mVelocityShader.uniform( "invHeight", 1.0f/(float)FBO_HEIGHT );
mVelocityShader.uniform( "dt", mRoom.getTimeDelta() );
mVelocityShader.uniform( "mainPower", mRoom.getPower() );
mVelocityShader.uniform( "gravity", mRoom.getGravity() );
gl::drawSolidRect( mFboBounds );
mVelocityShader.unbind();
mVelocityFbos[ mThisFbo ].unbindFramebuffer();
}
void TerrainApp::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() );
mCubeMap.bind();
mRoomShader.bind();
mRoomShader.uniform( "cubeMap", 0 );
mRoomShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix );
mRoomShader.uniform( "mMatrix", m );
mRoomShader.uniform( "eyePos", mSpringCam.mEye );
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 );
}
void shaderExternalFileExampleApp::draw(){
gl::clear( Color::black() );
if( mTexture ) {
mTexture.bind( 0 );
mShader.bind();
mShader.uniform( "texture", 0 );
mShader.uniform( "width", (float)CAM_W );
mShader.uniform( "height", (float)CAM_H );
gl::drawSolidRect( getWindowBounds() );
mShader.unbind();
mTexture.unbind();
}
}
void BasicBrickShaderApp::draw()
{
gl::setMatrices(mCam);
// clear out the window with black
gl::clear( Color( 0, 0, 0 ) );
mShader.bind();
mShader.uniform("LightPosition", mLightPos);
mShader.uniform("BrickColor", mBrickColor);
mShader.uniform("BrickPct", mBrickPct);
mShader.uniform("BrickSize", mBrickSize);
mShader.uniform("MortarColor", mMortarColor);
gl::drawCube(Vec3f::zero(), Vec3f(50.0f,50.0f,50.0f));
//gl::drawSphere(Vec3f::zero(), 50.0f);
mShader.unbind();
}
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 BasicShaderIIApp::draw()
{
gl::clear( Color::black() );
// Draw FPS
gl::color( Color::white() );
mTextureFont->drawString( toString( floor(getAverageFps()) ) + " FPS", Vec2f( 100, getWindowHeight() - mTextureFont->getDescent() ) );
gl::pushMatrices();
gl::setMatrices( mCam );
gl::enableAlphaBlending();
// draw interface
params::InterfaceGl::draw();
if( mDoSave )
{ // save non-conflicting image
// includes interface to record parameters
saveFrame();
mDoSave = false;
}
mShader.bind();
mShader.uniform("lightDir", mLightDir );
gl::pushMatrices();
gl::rotate( mArcball.getQuat() );
gl::draw( mVBO );
gl::popMatrices();
mShader.unbind();
gl::popMatrices();
}
void gpuPSApp::update()
{
gl::setMatricesWindow( mFBO[0].getSize(), false ); // false to prevent vertical flipping
gl::setViewport( mFBO[0].getBounds() );
mFBO[ mCurrentFBO ].bindFramebuffer();
GLenum buf[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
glDrawBuffers(2, buf);
mFBO[ mOtherFBO ].bindTexture(0, 0);
mFBO[ mOtherFBO ].bindTexture(1, 1);
mPosShader.bind();
mPosShader.uniform( "posArray", 0 );
mPosShader.uniform( "velArray", 1 );
glBegin(GL_QUADS);
glTexCoord2f( 0.0f, 0.0f); glVertex2f( 0.0f, 0.0f);
glTexCoord2f( 0.0f, 1.0f); glVertex2f( 0.0f, SIDE);
glTexCoord2f( 1.0f, 1.0f); glVertex2f( SIDE, SIDE);
glTexCoord2f( 1.0f, 0.0f); glVertex2f( SIDE, 0.0f);
glEnd();
mPosShader.unbind();
mFBO[ mOtherFBO ].unbindTexture();
mFBO[ mCurrentFBO ].unbindFramebuffer();
mCurrentFBO = ( mCurrentFBO + 1 ) % 2;
mOtherFBO = ( mCurrentFBO + 1 ) % 2;
}
void RepulsionApp::draw()
{
// clear out the window with black
gl::clear( ColorA( 0.1f, 0.1f, 0.1f, 0.0f ), true );
gl::setMatricesWindow( getWindowSize(), false );
gl::setViewport( getWindowBounds() );
gl::disableDepthRead();
gl::disableDepthWrite();
gl::enable( GL_TEXTURE_2D );
gl::enableAlphaBlending();
gl::color( ColorA( 1.0f, 1.0f, 1.0f, 1.0f ) );
// DRAW ROOM
mRoomFbo.bindTexture();
gl::drawSolidRect( getWindowBounds() );
gl::setMatrices( mSpringCam.getCam() );
// DRAW PANEL
drawInfoPanel();
gl::enable( GL_TEXTURE_2D );
gl::enableDepthRead();
gl::enableDepthWrite();
// DRAW PARTICLES
mPositionFbos[mThisFbo].bindTexture( 0 );
mVelocityFbos[mThisFbo].bindTexture( 1 );
mShader.bind();
mShader.uniform( "currentPosition", 0 );
mShader.uniform( "currentVelocity", 1 );
mShader.uniform( "eyePos", mSpringCam.getEye() );
mShader.uniform( "power", mRoom.getPower() );
gl::draw( mSphereVbo );
mShader.unbind();
if( mSaveFrames && mNumSavedFrames < 15000 ){
writeImage( *getHomeDirectory().c_str() + "RepulsionGPU/" + toString( mNumSavedFrames ) + ".png", copyWindowSurface() );
mNumSavedFrames ++;
}
mThisFbo = ( mThisFbo + 1 ) % 2;
mPrevFbo = ( mThisFbo + 1 ) % 2;
}
void PostProcessingApp::draw()
{
// clear window
gl::clear();
// bind shader and set shader variables
mShader.bind();
mShader.uniform( "tex0", 0 );
mShader.uniform( "time", (float)getElapsedSeconds() );
// draw image or video
gl::color( Color::white() );
gl::draw( mImage, getWindowBounds() );
// unbind shader
mShader.unbind();
}
/*
* @Description: need to blur[the SSAO texture] horizonatally then vertically (for shader performance reasons). Called ping-ponging as it one FBO drawn to another
* @param: KeyEvent
* @return: none
*/
void Base_ThreeD_ProjectApp::pingPongBlur()
{
//render horizontal blue first
gl::setViewport( mPingPongBlurH.getBounds() );
mPingPongBlurH.bindFramebuffer();
glClearColor( 0.5f, 0.5f, 0.5f, 1 );
glClearDepth(1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
gl::setMatricesWindow( mPingPongBlurH.getSize() );
mSSAOMap.getTexture().bind(0);
mHBlurShader.bind();
mHBlurShader.uniform("RTScene", 0);
gl::drawSolidRect( Rectf( 0, 0, getWindowWidth(), getWindowHeight()) );
mHBlurShader.unbind();
mSSAOMap.getTexture().unbind(0);
mPingPongBlurH.unbindFramebuffer();
//gl::setViewport( getWindowBounds() ); //redundant
//now render vertical blur
gl::setViewport( mPingPongBlurV.getBounds() );
mPingPongBlurV.bindFramebuffer();
glClearColor( 0.5f, 0.5f, 0.5f, 1 );
glClearDepth(1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
gl::setMatricesWindow( mPingPongBlurV.getSize() );
mPingPongBlurH.getTexture().bind(0);
mHBlurShader.bind();
mHBlurShader.uniform("RTBlurH", 0);
gl::drawSolidRect( Rectf( 0, 0, getWindowWidth(), getWindowHeight()) );
mHBlurShader.unbind();
mPingPongBlurH.getTexture().unbind(0);
mPingPongBlurV.unbindFramebuffer();
gl::setViewport( getWindowBounds() );
}
void gpuPSApp::draw()
{
gl::setMatrices( mMayaCam.getCamera() );
gl::setViewport( getWindowBounds() );
gl::clear( Color::white() );
mSwapFbo.bindTexture(0);
mSwapFbo.bindTexture(1);
mDisplacementShader.bind();
mDisplacementShader.uniform("displacementMap", 0 );
mDisplacementShader.uniform("velocityMap", 1);
gl::draw( mVboMesh );
mDisplacementShader.unbind();
mSwapFbo.unbindTexture();
gl::setMatricesWindow(getWindowSize());
gl::drawString( toString( SIDE*SIDE ) + " vertices", Vec2f(32.0f, 32.0f));
gl::drawString( toString((int) getAverageFps()) + " fps", Vec2f(32.0f, 52.0f));
}
void gpuPSApp::update()
{
if (mStep) {
computeAttractorPosition();
gl::setMatricesWindow( mSwapFbo.getSize(), false ); // false to prevent vertical flipping
gl::setViewport( mSwapFbo.getBounds() );
mSwapFbo.updateBind();
mParticlesShader.bind();
mParticlesShader.uniform( "positions", 0 );
mParticlesShader.uniform( "velocities", 1 );
mParticlesShader.uniform( "attractorPos", mAttractor);
gl::drawSolidRect(mSwapFbo.getBounds());
mParticlesShader.unbind();
mSwapFbo.updateUnbind();
mSwapFbo.swap();
}
}
void RepulsionApp::drawIntoPositionFbo()
{
gl::setMatricesWindow( mFboSize, false );
gl::setViewport( mFboBounds );
mPositionFbos[ mThisFbo ].bindFramebuffer();
mPositionFbos[ mPrevFbo ].bindTexture( 0, 0 );
mPositionFbos[ mPrevFbo ].bindTexture( 1, 1 );
mVelocityFbos[ mThisFbo ].bindTexture( 2, 0 );
mVelocityFbos[ mThisFbo ].bindTexture( 3, 1 );
mPositionShader.bind();
mPositionShader.uniform( "pos0Tex", 0 );
mPositionShader.uniform( "pos1Tex", 1 );
mPositionShader.uniform( "vel0Tex", 2 );
mPositionShader.uniform( "vel1Tex", 3 );
mPositionShader.uniform( "dt", mRoom.getTimeDelta() );
gl::drawSolidRect( mFboBounds );
mPositionShader.unbind();
mPositionFbos[ mThisFbo ].unbindFramebuffer();
}
void EpicMonsterApp::flockToBody() {
if(timer.getSeconds() > mTimerSlower) {
timer.stop();
timer.start();
gl::setMatricesWindow( mPPFbo.getSize(), false ); // false to prevent vertical flipping;
mPPFbo.updateBind();
mBakeShader.bind();
mBakeShader.uniform( "positions", 0 );
mBakeShader.uniform( "scale", mNormalScale );
mBakeShader.uniform( "velocities", 1 );
mBakeShader.uniform( "n", n);
mBakeShader.uniform( "attractorPos", mAttractor);
mBakeShader.uniform( "offset", Vec3f(mParTexOffset.x, mParTexOffset.y, mParIteration));
glDisable(GL_CULL_FACE);
mAssimpLoader.draw();
mBakeShader.unbind();
mPPFbo.updateUnbind();
mPPFbo.swap();
mParIteration+= triangles;
if(mParIteration > (6*n.x*n.x))
mParIteration = 0;
// TODO: baketuksessa overflowaa tyylikkäästi takaisin alkuun, jos menee yli
}
}
