void GeometryShaderTest::draw()
{
gl::clear(Color(0,0,0));
gl::color(Color(1,1,1));
shader.bind();
glLineWidth(2.0);
glBegin(GL_LINES);
glVertex2f(mouse.x, mouse.y);
glVertex2f(mouse.x + 100, mouse.y);
glEnd();
t += 0.1;
glLineWidth(0.5);
glBegin(GL_LINES);
int numLines = 10000;
for(int i=0; i<numLines; i++) {
float w = getWindowWidth() / (float)numLines;
float h = getWindowHeight() / (float)numLines;
float x = t + i * w;
float y = getWindowHeight() / 2.0;
y += (i % 2 == 0) ? 100 : -100;
glVertex2f(x, y);
glVertex2f(x, y + 50);
}
glEnd();
shader.unbind();
printf("FPS %f\n", getAverageFps());
}
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 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 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 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 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 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 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 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 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 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 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();
}
// Render the torus into the FBO
void FBOMultipleTargetsApp::renderSceneToFbo()
{
// 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 both of the attachments of the FBO with black
gl::clear();
// render the torus with our multiple-output shader
mShaderMultipleOuts.bind();
gl::drawTorus( 1.4f, 0.3f, 32, 64 );
mShaderMultipleOuts.unbind();
// unbind the framebuffer, so that drawing goes to the screen again
mFbo.unbindFramebuffer();
}
void EarthquakeApp::draw()
{
glClearColor( 1.0f, 0.0f, 0.0f, 1.0f );
gl::enableAlphaBlending();
gl::enableDepthRead( true );
gl::enableDepthWrite( true );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_TEXTURE_2D );
glDisable( GL_TEXTURE_RECTANGLE_ARB );
gl::GlslProg::unbind();
glColor4f( 1, 1, 1, 1 );
mStars.enableAndBind();
gl::drawSphere( Vec3f( 0, 0, 0 ), 15000.0f, 64 );
//gl::rotate( Quatf( Vec3f::zAxis(), -0.2f ) );
//gl::rotate( Quatf( Vec3f::yAxis(), mCounter*0.1f ) );
if( mShowEarth ){
mEarthShader.bind();
mEarthShader.uniform( "texDiffuse", 0 );
mEarthShader.uniform( "texNormal", 1 );
mEarthShader.uniform( "texMask", 2 );
mEarthShader.uniform( "counter", mCounter );
mEarthShader.uniform( "lightDir", mLightDir );
mEarth.draw();
mEarthShader.unbind();
}
glDisable( GL_TEXTURE_2D );
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
if( mShowQuakes ){
mQuakeShader.bind();
mQuakeShader.uniform( "lightDir", mLightDir );
mEarth.drawQuakeVectors();
mQuakeShader.unbind();
}
if( mShowText ){
gl::enableDepthWrite( false );
glEnable( GL_TEXTURE_2D );
//mEarth.drawQuakeLabelsOnBillboard( sBillboardRight, sBillboardUp );
mEarth.drawQuakeLabelsOnSphere( mPov.mEyeNormal, mPov.mDist );
glDisable( GL_TEXTURE_2D );
}
if( mSaveFrames ){
//writeImage( getHomeDirectory() / "CinderScreengrabs" / "Highoutput_" + toString( mCurrentFrame ) + ".png", copyWindowSurface() );
mCurrentFrame++;
}
}
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 BasicEarthApp::draw()
{
// clear out the window with black
gl::clear( Color( 0, 0, 0 ) );
mShader.bind();
gl::drawSphere(Vec3f::zero(), 50.0f);
mShader.unbind();
}
/*
* @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 ShadowMapSample::setup()
{
glPolygonOffset( 1.0f, 1.0f );
glEnable( GL_LIGHTING );
glEnable( GL_DEPTH_TEST );
mPaused = false;
mLookThroughCamera = true;
mDrawDepthMap = false;
mCamera = new CameraPersp( getWindowWidth(), getWindowHeight(), 45.0f );
mCamera->lookAt( vec3( 5, 5, 5 ), vec3( 0, 0, 0 ) );
mCamera->setPerspective( 45.0f, getWindowAspectRatio(), 0.1f, 100.0f );
mLight = new gl::Light( gl::Light::POINT, 0 );
mLight->lookAt( vec3( 1, 5, 1 ), vec3( 0, 0, 0 ) );
mLight->setAmbient( Color( 0.3f, 0.3f, 0.3f ) );
mLight->setDiffuse( Color( 0.5f, 0.5f, 0.5f ) );
mLight->setSpecular( Color( 0.5f, 0.5f, 0.5f ) );
mLight->setShadowParams( 60.0f, 0.5f, 8.0f );
mLight->update( *mCamera );
mLight->enable();
gl::Material torusMaterial;
torusMaterial.setSpecular( BLUE );
torusMaterial.setDiffuse( BLUE );
torusMaterial.setAmbient( Color( 0.1f, 0.1f, 0.1f ) );
torusMaterial.setShininess( 25.0f );
gl::Material backboardMaterial;
backboardMaterial.setAmbient( RED );
backboardMaterial.setDiffuse( RED );
backboardMaterial.setShininess( 1.0f );
initShadowMap();
mTorus = gl::DisplayList( GL_COMPILE );
mTorus.newList();
gl::drawTorus( 1.0f, 0.3f, 32, 64 );
mTorus.endList();
mTorus.setMaterial( torusMaterial );
mBackboard = gl::DisplayList( GL_COMPILE );
mBackboard.newList();
gl::drawCube( vec3( 0.0f, -2.5f, 0.0f ), vec3( 5.0f, 0.1f, 5.0f ) );
mBackboard.endList();
mBackboard.setMaterial( backboardMaterial );
mShader = gl::GlslProg( loadResource( RES_SHADOWMAP_VERT ), loadResource( RES_SHADOWMAP_FRAG ) );
mShader.bind();
mShader.uniform( "depthTexture", 0 );
}
void BasicEditorApp::draw()
{
// clear out the window with black
gl::clear( Color( 0, 0, 0 ) );
if( mShader ){
gl::enableAlphaBlending();
mShader.bind();
gl::drawSolidRect( getWindowBounds() );
mShader.unbind();
gl::disableAlphaBlending();
}
}
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
}
}
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 kinectPointCloudApp::draw()
{
gl::clear( Color( 0.0f, 0.0f, 0.0f ), true );
gl::pushMatrices();
gl::scale( Vec3f( -1.0f, -1.0f, 1.0f ) );
gl::rotate( mSceneRotation );
mDepthTexture.bind( 0 );
mShader.bind();
mShader.uniform( "depthTex", 0 );
gl::draw( mVboMesh );
mShader.unbind();
gl::popMatrices();
params::InterfaceGl::draw();
}
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 ObjLoaderApp::setup()
{
ObjLoader loader( loadResource( RES_CUBE_OBJ )->createStream() );
loader.load( &mMesh );
mVBO = gl::VboMesh( mMesh );
mTexture = gl::Texture( loadImage( loadResource( RES_IMAGE ) ) );
mShader = gl::GlslProg( loadResource( RES_SHADER_VERT ), loadResource( RES_SHADER_FRAG ) );
CameraPersp initialCam;
initialCam.setPerspective( 45.0f, getWindowAspectRatio(), 0.1, 10000 );
mMayaCam.setCurrentCam( initialCam );
mTexture.bind();
mShader.bind();
mShader.uniform( "tex0", 0 );
}
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();
}
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 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 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();
}
