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();
}
示例#6
0
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);
}
示例#7
0
文件: FolApp.cpp 项目: gaborpapp/apps
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);

}