void kinectPointCloudApp::createVbo()
{
gl::VboMesh::Layout layout;
layout.setStaticPositions();
layout.setStaticTexCoords2d();
layout.setStaticIndices();
std::vector<Vec3f> positions;
std::vector<Vec2f> texCoords;
std::vector<uint32_t> indices;
int numVertices = VBO_X_RES * VBO_Y_RES;
int numShapes = ( VBO_X_RES - 1 ) * ( VBO_Y_RES - 1 );
mVboMesh = gl::VboMesh( numVertices, numShapes, layout, GL_POINTS );
for( int x=0; x<VBO_X_RES; ++x ){
for( int y=0; y<VBO_Y_RES; ++y ){
indices.push_back( x * VBO_Y_RES + y );
float xPer = x / (float)(VBO_X_RES-1);
float yPer = y / (float)(VBO_Y_RES-1);
positions.push_back( Vec3f( ( xPer * 2.0f - 1.0f ) * VBO_X_RES, ( yPer * 2.0f - 1.0f ) * VBO_Y_RES, 0.0f ) );
texCoords.push_back( Vec2f( xPer, yPer ) );
}
}
mVboMesh.bufferPositions( positions );
mVboMesh.bufferIndices( indices );
mVboMesh.bufferTexCoords2d( 0, texCoords );
}
void EpicMonsterApp::setupVBO(){
/* A dummy VboMesh the same size as the
texture to keep the vertices on the GPU */
int totalVertices = SIDE * SIDE;
vector<Vec2f> texCoords;
vector<uint32_t> indices;
gl::VboMesh::Layout layout;
layout.setStaticIndices();
layout.setStaticPositions();
layout.setStaticTexCoords2d();
layout.setStaticNormals();
layout.setDynamicColorsRGBA();
glPointSize(1.0f);
mVboMesh = gl::VboMesh( totalVertices, totalVertices, layout, GL_POINTS);
for( int x = 0; x < SIDE; ++x ) {
for( int y = 0; y < SIDE; ++y ) {
indices.push_back( x * SIDE + y );
texCoords.push_back( Vec2f( x/(float)SIDE, y/(float)SIDE ) );
}
}
mVboMesh.bufferIndices( indices );
mVboMesh.bufferTexCoords2d( 0, texCoords );
}
void BouncingBallsApp::setup()
{
// randomize the random generator
Rand::randSeed( clock() );
//
mUseMotionBlur = true;
// set some kind of sensible maximum to the frame rate
setFrameRate(100.0f);
// initialize simulator
mStepsPerSecond = 60;
mStepsPerformed = 0;
// create a single ball
mBalls.push_back( BallRef( new Ball() ) );
// create ball mesh ( much faster than using gl::drawSolidCircle() )
size_t slices = 20;
std::vector<Vec3f> positions;
std::vector<Vec2f> texcoords;
std::vector<uint32_t> indices;
indices.push_back( positions.size() );
texcoords.push_back( Vec2f(0.5f, 0.5f) );
positions.push_back( Vec3f::zero() );
for(size_t i=0;i<=slices;++i) {
float angle = i / (float) slices * 2.0f * (float) M_PI;
Vec2f v(sinf(angle), cosf(angle));
indices.push_back( positions.size() );
texcoords.push_back( Vec2f(0.5f, 0.5f) + 0.5f * v );
positions.push_back( Ball::RADIUS * Vec3f(v, 0.0f) );
}
gl::VboMesh::Layout layout;
layout.setStaticPositions();
layout.setStaticTexCoords2d();
layout.setStaticIndices();
mMesh = gl::VboMesh( (size_t) (slices + 2), (size_t) (slices + 2), layout, GL_TRIANGLE_FAN );
mMesh.bufferPositions( &positions.front(), positions.size() );
mMesh.bufferTexCoords2d(0, texcoords);
mMesh.bufferIndices( indices );
// load texture
mTexture = gl::Texture( loadImage( loadAsset("ball.png") ) );
// start simulation
mTimer.start();
}
void GeometryShaderApp::update()
{
// brute-force method: recreate mesh if anything changed
if( !mVboMesh ) {
if( mPoints.size() > 1 ) {
// create a new vector that can contain 3D vertices
std::vector<Vec3f> vertices;
// to improve performance, make room for the vertices + 2 adjacency vertices
vertices.reserve( mPoints.size() + 2);
// first, add an adjacency vertex at the beginning
vertices.push_back( 2.0f * Vec3f(mPoints[0]) - Vec3f(mPoints[1]) );
// next, add all 2D points as 3D vertices
std::vector<Vec2f>::iterator itr;
for(itr=mPoints.begin();itr!=mPoints.end();++itr)
vertices.push_back( Vec3f( *itr ) );
// next, add an adjacency vertex at the end
size_t n = mPoints.size();
vertices.push_back( 2.0f * Vec3f(mPoints[n-1]) - Vec3f(mPoints[n-2]) );
// now that we have a list of vertices, create the index buffer
n = vertices.size() - 2;
std::vector<uint32_t> indices;
indices.reserve( n * 4 );
for(size_t i=1;i<vertices.size()-2;++i) {
indices.push_back(i-1);
indices.push_back(i);
indices.push_back(i+1);
indices.push_back(i+2);
}
// finally, create the mesh
gl::VboMesh::Layout layout;
layout.setStaticPositions();
layout.setStaticIndices();
mVboMesh = gl::VboMesh( vertices.size(), indices.size(), layout, GL_LINES_ADJACENCY_EXT );
mVboMesh.bufferPositions( &(vertices.front()), vertices.size() );
mVboMesh.bufferIndices( indices );
}
else
mVboMesh = gl::VboMesh();
}
}
void FastTrailsApp::setup()
{
// initialize camera
CameraPersp cam( getWindowWidth(), getWindowHeight(), 60.0f, 0.1f, 500.0f );
cam.setEyePoint( Vec3f(0, 0, -100.0f) );
cam.setCenterOfInterestPoint( Vec3f::zero() );
mCamera.setCurrentCam( cam );
// load texture
try { mTexture = gl::Texture( loadImage( loadAsset("gradient.png") ) ); }
catch( const std::exception &e ) { console() << e.what() << std::endl; }
// create VBO mesh
gl::VboMesh::Layout layout;
layout.setDynamicPositions();
layout.setStaticIndices();
layout.setStaticTexCoords2d();
mVboMesh = gl::VboMesh( TRAIL_LENGTH, TRAIL_LENGTH, layout, GL_TRIANGLE_STRIP );
// observation: indices and texture coordinates never change
std::vector< uint32_t > indices; indices.reserve( TRAIL_LENGTH );
std::vector< Vec2f > texcoords; texcoords.reserve( TRAIL_LENGTH );
for( size_t i=0; i<TRAIL_LENGTH; ++i ) {
indices.push_back( i );
float x = math<float>::floor( i * 0.5f ) / ( TRAIL_LENGTH * 0.5f );
float y = float( i % 2 );
texcoords.push_back( Vec2f( x, y ) );
}
// create index and texture coordinate buffers
mVboMesh.bufferIndices( indices );
mVboMesh.bufferTexCoords2d( 0, texcoords );
// clear our trail buffer
mTrail.clear();
// initialize time and angle
mTime = getElapsedSeconds();
mAngle= 0.0f;
// disable vertical sync, so we can see the actual frame rate
gl::disableVerticalSync();
}
void VboSampleApp::setup()
{
mCamera.setAspectRatio(getWindowAspectRatio());
mTexture = bluegin::getTextureAsset("cinder_logo.png");
mTexture.setMinFilter(GL_LINEAR);
mTexture.setMagFilter(GL_LINEAR);
gl::VboMesh::Layout layout;
layout.setStaticIndices();
layout.setStaticPositions();
layout.setStaticTexCoords2d();
const int vertexCount = 4;
const int indexCount = 6;
mVboMesh = gl::VboMesh( vertexCount, indexCount, layout, GL_TRIANGLES );
vector<Vec3f> positions;
positions.push_back(Vec3f(-1.0f, 1.0f, 0));
positions.push_back(Vec3f(-1.0f, -1.0f, 0));
positions.push_back(Vec3f(1.0f, -1.0f, 0));
positions.push_back(Vec3f(1.0f, 1.0f, 0));
mVboMesh.bufferPositions(positions);
vector<Vec2f> texcoords;
texcoords.push_back(Vec2f(0, 0));
texcoords.push_back(Vec2f(0, 1.0f));
texcoords.push_back(Vec2f(1.0f, 1.0f));
texcoords.push_back(Vec2f(1.0f, 0));
mVboMesh.bufferTexCoords2d(0, texcoords);
vector<index_t> indices;
indices.push_back(index_t(0));
indices.push_back(index_t(1));
indices.push_back(index_t(2));
indices.push_back(index_t(2));
indices.push_back(index_t(3));
indices.push_back(index_t(0));
mVboMesh.bufferIndices(indices);
}
void FolApp::createVbo()
{
gl::VboMesh::Layout layout;
layout.setStaticPositions();
layout.setStaticTexCoords2d();
layout.setStaticIndices();
std::vector<Vec3f> positions;
std::vector<Vec2f> texCoords;
std::vector<uint32_t> indices;
int numVertices = VBO_X_SIZE * VBO_Y_SIZE;
int numShapes = ( VBO_X_SIZE - 1 ) * ( VBO_Y_SIZE - 1 );
mVboMesh = gl::VboMesh( numVertices, numShapes, layout, GL_POINTS );
for ( int x = 0; x < VBO_X_SIZE; x++ )
{
for ( int y = 0; y < VBO_Y_SIZE; y++ )
{
indices.push_back( x * VBO_Y_SIZE + y );
float xPer = x / (float)( VBO_X_SIZE - 1 );
float yPer = y / (float)( VBO_Y_SIZE - 1 );
/*
positions.push_back( Vec3f( ( xPer * 2.0f - 1.0f ) * VBO_X_SIZE,
( yPer * 2.0f - 1.0f ) * VBO_Y_SIZE,
0.0f ) );
*/
positions.push_back( Vec3f( x, y, 0 ) );
texCoords.push_back( Vec2f( xPer, yPer ) );
}
}
mVboMesh.bufferPositions( positions );
mVboMesh.bufferIndices( indices );
mVboMesh.bufferTexCoords2d( 0, texCoords );
//mVboMesh.unbindBuffers();
}
void AudioVisualizerApp::setup()
{
// initialize signals
signalChannelEnd = false;
// make a list of valid audio file extensions and initialize audio variables
const char* extensions[] = {"mp3", "wav", "ogg"};
mAudioExtensions = vector<string>(extensions, extensions+2);
mAudioPath = getAssetPath("");
mIsAudioPlaying = false;
// setup camera
mCamera.setPerspective(50.0f, 1.0f, 1.0f, 10000.0f);
mCamera.setEyePoint( Vec3f(-kWidth/4, kHeight/2, -kWidth/8) );
mCamera.setCenterOfInterestPoint( Vec3f(kWidth/4, -kHeight/8, kWidth/4) );
// create channels from which we can construct our textures
mChannelLeft = Channel32f(kBands, kHistory);
mChannelRight = Channel32f(kBands, kHistory);
memset( mChannelLeft.getData(), 0, mChannelLeft.getRowBytes() * kHistory );
memset( mChannelRight.getData(), 0, mChannelRight.getRowBytes() * kHistory );
// create texture format (wrap the y-axis, clamp the x-axis)
mTextureFormat.setWrapS( GL_CLAMP );
mTextureFormat.setWrapT( GL_REPEAT );
mTextureFormat.setMinFilter( GL_LINEAR );
mTextureFormat.setMagFilter( GL_LINEAR );
// compile shader
try {
mShader = gl::GlslProg( loadAsset("shaders/spectrum.vert"), loadAsset("shaders/spectrum.frag") );
}
catch( const std::exception& e ) {
console() << e.what() << std::endl;
quit();
return;
}
// create static mesh (all animation is done in the vertex shader)
std::vector<Vec3f> vertices;
std::vector<Colorf> colors;
std::vector<Vec2f> coords;
std::vector<size_t> indices;
for(size_t h=0;h<kHeight;++h)
{
for(size_t w=0;w<kWidth;++w)
{
// add polygon indices
if(h < kHeight-1 && w < kWidth-1)
{
size_t offset = vertices.size();
indices.push_back(offset);
indices.push_back(offset+kWidth);
indices.push_back(offset+kWidth+1);
indices.push_back(offset);
indices.push_back(offset+kWidth+1);
indices.push_back(offset+1);
}
// add vertex
vertices.push_back( Vec3f(float(w), 0, float(h)) );
// add texture coordinates
// note: we only want to draw the lower part of the frequency bands,
// so we scale the coordinates a bit
const float part = 0.5f;
float s = w / float(kWidth-1);
float t = h / float(kHeight-1);
coords.push_back( Vec2f(part - part * s, t) );
// add vertex colors
colors.push_back( Color(CM_HSV, s, 0.5f, 0.75f) );
}
}
gl::VboMesh::Layout layout;
layout.setStaticPositions();
layout.setStaticColorsRGB();
layout.setStaticIndices();
layout.setStaticTexCoords2d();
mMesh = gl::VboMesh(vertices.size(), indices.size(), layout, GL_TRIANGLES);
mMesh.bufferPositions(vertices);
mMesh.bufferColorsRGB(colors);
mMesh.bufferIndices(indices);
mMesh.bufferTexCoords2d(0, coords);
// play audio using the Cinder FMOD block
FMOD::System_Create( &mFMODSystem );
mFMODSystem->init( 32, FMOD_INIT_NORMAL | FMOD_INIT_ENABLE_PROFILE, NULL );
mFMODSound = nullptr;
mFMODChannel = nullptr;
playAudio( findAudio( mAudioPath ) );
mIsMouseDown = false;
mMouseUpDelay = 30.0;
mMouseUpTime = getElapsedSeconds() - mMouseUpDelay;
// the texture offset has two purposes:
// 1) it tells us where to upload the next spectrum data
// 2) we use it to offset the texture coordinates in the shader for the scrolling effect
mOffset = 0;
}
void millionParticlesApp::setup()
{
gl::clear();
try {
mPosShader = gl::GlslProg(ci::app::loadResource(POS_VS),ci::app::loadResource(POS_FS));
mVelShader = gl::GlslProg(ci::app::loadResource(VEL_VS),ci::app::loadResource(VEL_FS));
}
catch( gl::GlslProgCompileExc &exc ) {
std::cout << "Shader compile error: " << std::endl;
std::cout << exc.what();
}
catch( ... ) {
std::cout << "Unable to load shader" << std::endl;
}
//controls
mDrawTextures = false;
mIsFullScreen = false;
mFrameCounter = 0;
mPerlin = Perlin(32,clock() * .1f);
//initialize buffer
Surface32f mPosSurface = Surface32f(PARTICLES,PARTICLES,true);
Surface32f mVelSurface = Surface32f(PARTICLES,PARTICLES,true);
Surface32f mInfoSurface = Surface32f(PARTICLES,PARTICLES,true);
Surface32f mNoiseSurface = Surface32f(PARTICLES,PARTICLES,true);
Surface32f::Iter iterator = mPosSurface.getIter();
while(iterator.line())
{
while(iterator.pixel())
{
mVertPos = Vec3f(Rand::randFloat(getWindowWidth()) / (float)getWindowWidth(),
Rand::randFloat(getWindowHeight()) / (float)getWindowHeight(),0.0f);
//velocity
Vec2f vel = Vec2f(Rand::randFloat(-.005f,.005f),Rand::randFloat(-.005f,.005f));
float nX = iterator.x() * 0.005f;
float nY = iterator.y() * 0.005f;
float nZ = app::getElapsedSeconds() * 0.1f;
Vec3f v( nX, nY, nZ );
float noise = mPerlin.fBm( v );
float angle = noise * 15.0f ;
//vel = Vec3f( cos( angle ) * 6.28f, cos( angle ) * 6.28f, 0.0f );
//noise
mNoiseSurface.setPixel(iterator.getPos(),
Color( cos( angle ) * Rand::randFloat(.00005f,.0002f), sin( angle ) * Rand::randFloat(.00005f,.0002f), 0.0f ));
//position + mass
mPosSurface.setPixel(iterator.getPos(),
ColorA(mVertPos.x,mVertPos.y,mVertPos.z,
Rand::randFloat(.00005f,.0002f)));
//forces + decay
mVelSurface.setPixel(iterator.getPos(), Color(vel.x,vel.y, Rand::randFloat(.01f,1.00f)));
//particle age
mInfoSurface.setPixel(iterator.getPos(),
ColorA(Rand::randFloat(.007f,1.0f), 1.0f,0.00f,1.00f));
}
}
//gl texture settings
gl::Texture::Format tFormat;
tFormat.setInternalFormat(GL_RGBA16F_ARB);
gl::Texture::Format tFormatSmall;
tFormat.setInternalFormat(GL_RGBA8);
mSpriteTex = gl::Texture( loadImage( loadResource( "point.png" ) ), tFormatSmall);
mNoiseTex = gl::Texture(mNoiseSurface, tFormatSmall);
mNoiseTex.setWrap( GL_REPEAT, GL_REPEAT );
mNoiseTex.setMinFilter( GL_NEAREST );
mNoiseTex.setMagFilter( GL_NEAREST );
mPosTex = gl::Texture(mPosSurface, tFormat);
mPosTex.setWrap( GL_REPEAT, GL_REPEAT );
mPosTex.setMinFilter( GL_NEAREST );
mPosTex.setMagFilter( GL_NEAREST );
mVelTex = gl::Texture(mVelSurface, tFormat);
mVelTex.setWrap( GL_REPEAT, GL_REPEAT );
mVelTex.setMinFilter( GL_NEAREST );
mVelTex.setMagFilter( GL_NEAREST );
mInfoTex = gl::Texture(mInfoSurface, tFormatSmall);
mInfoTex.setWrap( GL_REPEAT, GL_REPEAT );
mInfoTex.setMinFilter( GL_NEAREST );
mInfoTex.setMagFilter( GL_NEAREST );
//initialize fbo
gl::Fbo::Format format;
format.enableDepthBuffer(false);
format.enableColorBuffer(true, 3);
format.setMinFilter( GL_NEAREST );
format.setMagFilter( GL_NEAREST );
format.setWrap(GL_CLAMP,GL_CLAMP);
format.setColorInternalFormat( GL_RGBA16F_ARB );
mFbo[0] = gl::Fbo(PARTICLES,PARTICLES, format);
mFbo[1] = gl::Fbo(PARTICLES,PARTICLES, format);
initFBO();
//fill dummy fbo
vector<Vec2f> texCoords;
vector<Vec3f> vertCoords, normCoords;
vector<uint32_t> indices;
gl::VboMesh::Layout layout;
layout.setStaticIndices();
layout.setStaticPositions();
layout.setStaticTexCoords2d();
layout.setStaticNormals();
mVbo = gl::VboMesh(PARTICLES*PARTICLES,PARTICLES*PARTICLES,layout,GL_POINTS);
for (int x = 0; x < PARTICLES; ++x) {
for (int y = 0; y < PARTICLES; ++y) {
indices.push_back( x * PARTICLES + y);
texCoords.push_back( Vec2f( x/(float)PARTICLES, y/(float)PARTICLES));
}
}
mVbo.bufferIndices(indices);
mVbo.bufferTexCoords2d(0, texCoords);
}