C++ Perlin::fBm方法代码示例

void Particle::update(const Perlin &perlin)
{
	// get Perlin noise value based on my location and
	// elapsed seconds and turn this noise value into an angle.
	float nX = mLoc.x * 0.005f;
	float nY = mLoc.y * 0.005f;
	float nZ = app::getElapsedSeconds() * 0.1f;
	float noise = perlin.fBm( nX, nY, nZ );
	float angle = noise * 15.0f;
	Vec2f noiseVector( cos( angle ), sin( angle ) );
    
	mVel += noiseVector * 0.2f * ( 1.0f - mAgePercentage );
    
	mLoc += mVel;
    
    mVel *= mDecay;
    
    
    if (mLoc.x > 0 && mLoc.x < getWindowWidth() ) {
        mXPercentage = (float) mLoc.x / (float) getWindowWidth();
    }
    
    if (mLoc.y > 0 && mLoc.y < getWindowWidth() ) {
        mYPercentage = (float) mLoc.y / (float) getWindowHeight();
    }
    
    if (mAge > mLifespan) {
        mIsDead = true;
    } else {
        mAge++;
        mAgePercentage = (float) mAge / (float) mLifespan;
    }
    
}

void Particle::update( const Perlin &perlin, const Channel32f &channel, const Vec2i &mouseLoc )
{	
	
    angle1 += M_PI/100;
    
    // get Perlin noise value based on my location and
	// elapsed seconds and turn this noise value into an angle.
	float nX = mLoc.x * 0.005f;
	float nY = mLoc.y * 0.005f;
	float nZ = app::getElapsedSeconds() * 0.1f;
	float noise = perlin.fBm( nX, nY, nZ );
	float angle = noise * 15.0f;
	Vec2f noiseVector( cos( angle ), sin( angle ) );

	mVel += noiseVector * 0.2f * ( 1.0f - mAgePer );
    
   // mLoc.x = startLoc.x + 120*sin(angle1);
   // mLoc.y = startLoc.y + 120*cos(angle1);
	mLoc += mVel;
	mVel *= mDecay;

	mRadius	= mScale * mAgePer;
	
	mAge++;
	if( mAge > mLifespan ) mIsDead = true;
	mAgePer = 1.0f - ( (float)mAge/(float)mLifespan );
}

void Particle::Step(float pElapsed, const Perlin &pNoise)
{
	Age--;
	if (Age>0)
	{
		PAlpha = math<float>::min(1, ((float)Age * 0.5f * (float)Age) / (float)mLifeSpan);

		PPosition.y += mVelocity.y;
		float cNoise = pNoise.fBm(vec3(PPosition.x*0.005f, PPosition.y*0.01f, PPosition.z*0.005f));
		float cAngle = cNoise*15.0f;
		PPosition.x += (cos(cAngle)*mVelocity.x*(1.0f-PAlpha))*0.1f;
		PPosition.z += (sin(cAngle)*mVelocity.z*(1.0f - PAlpha))*0.1f;
		mVelocity.x *= 1.001f;
		mVelocity.y *= .99999f;
		mVelocity.z *= 1.001f;

		float elapsedFrames = pElapsed;
		//PModelMatrix = mat4();
		//PModelMatrix = glm::rotate(PModelMatrix, mRotSpeed *elapsedFrames* 0.2f, vec3(0, 0, 1));
		//PModelMatrix = glm::rotate(PModelMatrix, mRotSpeed *elapsedFrames* 0.2f, vec3(1, 0, 0));
		//PModelMatrix = glm::rotate(PModelMatrix, mRotSpeed *elapsedFrames* 0.2f, vec3(0, 1, 0));
		//PModelMatrix = glm::translate(PModelMatrix, PPosition);



	}
}

void svvimApp::update() {
  float noise = mPerlinGenerator.fBm(Vec2f(0., app::getElapsedSeconds()));
  
  app::console() << noise << "\n";
  // Update alpha values
  getAlpha();

  if (mPoolWaterMovie)
    mMaskTexture = mPoolWaterMovie.getTexture();
  
  if (mCurrentMovie.isDone()) {
    incrementMovie();
  }
  
  app::console() << 10 * app::getElapsedSeconds() << "\n";
  

  mImageTexture = mCurrentMovie.getTexture();
  
  //mImageTexture = mCurrentBgTexture;
  
  // ...
  
  

}

void TerrainApp::addQuad( int x, int y )
{
	Vec2f p00( x, y );
	Vec2f p10( x + 1, y );
	Vec2f p11( x + 1, y + 1 );
	Vec2f p01( x, y + 1 );

	float zScale = mHeight;
	float noiseScale = mNoiseScale;
	float z00 = zScale * mPerlin.fBm( p00 * noiseScale );
	float z10 = zScale * mPerlin.fBm( p10 * noiseScale );
	float z11 = zScale * mPerlin.fBm( p11 * noiseScale );
	float z01 = zScale * mPerlin.fBm( p01 * noiseScale );

	size_t idx = mTriMesh.getNumVertices();

	// positions
	Vec3f t00( p00.x - xSize / 2., z00, p00.y - ySize / 2. );
	Vec3f t10( p10.x - xSize / 2., z10, p10.y - ySize / 2. );
	Vec3f t11( p11.x - xSize / 2., z11, p11.y - ySize / 2. );
	Vec3f t01( p01.x - xSize / 2., z01, p01.y - ySize / 2. );

	mTriMesh.appendVertex( t00 );
	mTriMesh.appendVertex( t10 );
	mTriMesh.appendVertex( t01 );

	mTriMesh.appendVertex( t10 );
	mTriMesh.appendVertex( t11 );
	mTriMesh.appendVertex( t01 );

	// normals
	Vec3f n0 = ( t10 - t00 ).cross( t10 - t01 ).normalized();
	Vec3f n1 = ( t11 - t10 ).cross( t11 - t01 ).normalized();
	mTriMesh.appendNormal( n0 );
	mTriMesh.appendNormal( n0 );
	mTriMesh.appendNormal( n0 );
	mTriMesh.appendNormal( n1 );
	mTriMesh.appendNormal( n1 );
	mTriMesh.appendNormal( n1 );

	mTriMesh.appendTriangle( idx, idx + 1, idx + 2 );
	mTriMesh.appendTriangle( idx + 3, idx + 4, idx + 5 );
}

void FurPoint::update(const Perlin &perlin, float stepX, float stepY, float stepZ){
    if (1.0f - age / lifetime <= 0.0f) isDead = true;
    if (position.x < 0 || position.x > getWindowWidth()) isDead = true;
    if (position.y < 0 || position.y > getWindowHeight()) isDead = true;
    
    noiseFloat = perlin.fBm( position.x * stepX, position.y * stepY, getElapsedFrames() * stepZ );
    noiseVec.x = cos(((noiseFloat) * M_PI_2) * 10.0f);
    noiseVec.y = sin(((noiseFloat) * M_PI_2) * 10.0f);
    velocity += noiseVec;
    velocity *= 0.5f;
    position += velocity;
    age++;
}

void Water::createHeightMap(){
    Perlin noise = Perlin(40);
    float channelSize = 400 ;
    cout << "Creating water height map - " << endl ;
    
    Channel heightMapChannel = Channel8u(channelSize, channelSize);
    
    Channel::Iter iter = heightMapChannel.getIter( heightMapChannel.getBounds());
    float max_value = -1.0 ;
    float min_value = 10001.0 ;
    
    while(iter.line()){
        while(iter.pixel()){
            Vec2f current = iter.getPos();
            float value = 255.0F * noise.fBm(5 * current.x/channelSize, 5 * current.y/channelSize);
            if( value > max_value){
                max_value = value ;
            }
            if( value < min_value){
                min_value = value ;
            }
        }
    }
    
    iter = heightMapChannel.getIter( heightMapChannel.getBounds());
    while(iter.line()){
        while(iter.pixel()){
            Vec2f current = iter.getPos();
            float value = 255.0f * noise.fBm(5 * current.x/channelSize, 5 * current.y/channelSize);
            value = 255.0f * (value - min_value) / (max_value - min_value);
            iter.v() = value ;
        }
    }
    
    heightMap = gl::Texture(heightMapChannel);
    cout << min_value << " " << max_value << endl ;
    cout << "Done creating water height map" << endl;
}

void Particle::update(float delta, Perlin &perlin) {
  const float noise = perlin.fBm(mPosition * 0.005f + app::getElapsedSeconds() * Vec3f(0.1f, 0.1f, 0.1f));
  const float angle = noise * 15.0f;
  
  mVelocity += 0.1f * Vec3f(cos(angle), sin(angle) - 0.3f, 2.0f * sin(angle) - 0.5f);
  mPosition += delta * mVelocity;
  mVelocity *= mVecolityDecay;
  
  mAge += 1;
  
  // flap
  if (mAge >= mLifespan) {
    mIsDead = true;
  }
}

void DelayFeedback::addSplash( const Vec2f &pos )
{
	mSplashes.push_back( Splash() );

	auto &splash = mSplashes.back();
	splash.mCenter = pos;
	splash.mAlpha = 1;

	float radiusMin = ( 1 - (float)pos.y / (float)getWindowHeight() ) * MAX_RADIUS / 2;
	splash.mRadius = randFloat( radiusMin, 30 );

	float endRadius = randFloat( MAX_RADIUS * 0.9f, MAX_RADIUS );
	timeline().apply( &splash.mRadius, endRadius, 7, EaseOutExpo() );
	timeline().apply( &splash.mAlpha, 0.0f, 7 );

	float h = math<float>::min( 1,  mPerlin.fBm( pos.normalized() ) * 7.0f );
	splash.mColorHsv = Vec3f( fabsf( h ), 1, 1 );
}

void SpiderWebApp::setupBuffers()
{
	
	// get all of the points from the spider web
	
	 // buffer the positions
	std::array<vec4, MAX_POINTS> positions;
	std::array<vec3, MAX_POINTS> velocities;
	std::array<ivec4, MAX_POINTS> connections;
	std::array<vec4, MAX_POINTS> connectionLen;
	std::array<vec4, MAX_POINTS> colors;
	
	vector<ParticleRef> webPoints = mWeb->getPoints();
	int n = 0;
	Perlin p = Perlin();
	for( auto iter = webPoints.begin(); iter != webPoints.end(); ++iter ) {
		auto point = (*iter);
		vec2 pos = point->getPosition();
		// create our initial positions
		positions[point->getId()] = vec4(
			pos.x, pos.y,
			0.0,
			1.0f );
		// zero out velocities
		velocities[point->getId()] = vec3( 0.0f );
		
		connections[n] = ivec4( -1 );
		connectionLen[n] = vec4( 0.0 );
		auto conn = point->getNeighbors();
		// use first 4 connections of there are more
		int max = min(int(conn.size()), 4);

		for( int i = 0; i < max; ++i ){
			auto connection = conn[i];
			connections[n][i] = connection->getId();
//			connectionLen[n][i] = distance( normalize(pos), normalize(connection->getPosition()) );
			connectionLen[n][i] = distance( pos, connection->getPosition() );
		}
		n++;
		
		// DEFINE alpha - helps make the line thickness look a bit varied
		float x = pos.x / getWindowWidth();
		float y = pos.y / getWindowHeight();
		float a = p.fBm( x, y ) * 2.0;
		a += 0.35;
		colors[point->getId()] = vec4( vec3( 1.0 ), a );
	}
	
	for ( int i = 0; i < 2; i++ ) {
		mVaos[i] = gl::Vao::create();
		gl::ScopedVao scopeVao( mVaos[i] );
		{
			// buffer the positions
			mPositions[i] = gl::Vbo::create( GL_ARRAY_BUFFER, positions.size() * sizeof(vec4), positions.data(), GL_STATIC_DRAW );
			{
				// bind and explain the vbo to your vao so that it knows how to distribute vertices to your shaders.
				gl::ScopedBuffer sccopeBuffer( mPositions[i] );
				gl::vertexAttribPointer( POSITION_INDEX, 4, GL_FLOAT, GL_FALSE, 0, (const GLvoid*) 0 );
				gl::enableVertexAttribArray( POSITION_INDEX );
			}
			
			// buffer the velocities
			mVelocities[i] = gl::Vbo::create( GL_ARRAY_BUFFER, velocities.size() * sizeof(vec3), velocities.data(), GL_STATIC_DRAW );
			{
				// bind and explain the vbo to your vao so that it knows how to distribute vertices to your shaders.
				gl::ScopedBuffer scopeBuffer( mVelocities[i] );
				gl::vertexAttribPointer( VELOCITY_INDEX, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid*) 0 );
				gl::enableVertexAttribArray( VELOCITY_INDEX );
			}
			// buffer the connections
			mConnections[i] = gl::Vbo::create( GL_ARRAY_BUFFER, connections.size() * sizeof(ivec4), connections.data(), GL_STATIC_DRAW );
			{
				// bind and explain the vbo to your vao so that it knows how to distribute vertices to your shaders.
				gl::ScopedBuffer scopeBuffer( mConnections[i] );
				gl::vertexAttribIPointer( CONNECTION_INDEX, 4, GL_INT, 0, (const GLvoid*) 0 );
				gl::enableVertexAttribArray( CONNECTION_INDEX );
			}
			// buffer the connection lengths
			mConnectionLen[i] = gl::Vbo::create( GL_ARRAY_BUFFER, connectionLen.size() * sizeof(vec4), connectionLen.data(), GL_STATIC_DRAW );
			{
				// bind and explain the vbo to your vao so that it knows how to distribute vertices to your shaders.
				gl::ScopedBuffer scopeBuffer( mConnectionLen[i] );
				gl::vertexAttribPointer( CONNECTION_LEN_INDEX, 4, GL_FLOAT, GL_FLOAT, 0, (const GLvoid*) 0 );
				gl::enableVertexAttribArray( CONNECTION_LEN_INDEX );
			}
			
			// buffer the colors
			mColors[i] = gl::Vbo::create( GL_ARRAY_BUFFER, colors.size() * sizeof(vec4), colors.data(), GL_STATIC_DRAW );
			{
				// bind and explain the vbo to your vao so that it knows how to distribute vertices to your shaders.
				gl::ScopedBuffer scopeBuffer( mColors[i] );
				gl::vertexAttribPointer( COLOR_INDEX, 4, GL_FLOAT, GL_FALSE, 0, (const GLvoid*) 0 );
				gl::enableVertexAttribArray( COLOR_INDEX );
			}
			
			// Create a TransformFeedbackObj, which is similar to Vao
			// It's used to capture the output of a glsl and uses the
			// index of the feedback's varying variable names.
			mFeedbackObj[i] = gl::TransformFeedbackObj::create();
			// Bind the TransformFeedbackObj and bind each corresponding buffer
//.........这里部分代码省略.........

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 );
//.........这里部分代码省略.........