Particle::Particle( const Vec2f& origin, Rand& r )
: position( origin ),
lifespan( 1.0f ),
velocity( r.nextFloat( -1.0f, 1.0f ), r.nextFloat( -1.0f, 1.0f ) ),
acceleration( 0.0f, r.nextFloat( 0.01f, 0.03f ) ),
aging( r.nextFloat( ( 1.0f / 64 ), ( 1.0f / 128 ) ) ),
sizeRadius( r.nextFloat( 3.0f, 9.0f ) )
{ }
void loseScore(Vec2f impact, int num)
{
vel -= impact;
closestPlanet = 0;
for(int i = 0; i < num; i++)
losing.push_back(new Particle(pos, Vec2f(rand->nextFloat(20.5f), rand->nextFloat(20.5f)), 5.0f, color));
}
Particle(vector<Tile*> *_tiles, Tile *_tile, Vec2f _pos, float _lifetime, Rand* _r)
{
tiles = _tiles;
tile = _tile;
lifetime = _lifetime;
pos = _pos;
expired = .0f;
rand = _r;
vel = Vec2f(rand->nextFloat(-PSPEED, PSPEED), rand->nextFloat(-PSPEED, PSPEED));
}
void update(float dt)
{
Vec2f newpos = pos + vel;
if(insidePolygon(newpos - tile->pos, (*tile->hex)))
{
pos = newpos;
}
else
{
Vec2f newpos2 = pos + vel * 15.0f;
Vec2f exitdir = newpos2 - tile->pos;
bool wander = false;
vector<Tile*>::iterator tileit;
int idx = Tile::getIndexForAngle(math<float>::atan2(exitdir.x, exitdir.y));
console() << idx << endl;
for(tileit = tiles->begin(); tileit < tiles->end(); tileit++)
{
if(insidePolygon(newpos2 - (*tileit)->pos, *(*tileit)->hex) &&
tile->connections[idx] &&
!tile->state[idx] &&
!(*tileit)->state[(idx+3) % 6])
{
pos = newpos;
wander = true;
tile = tile->connections[idx];
}
}
if(!wander)
{
Rand r;
vel = Vec2f(rand->nextFloat(-PSPEED, PSPEED), rand->nextFloat(-PSPEED, PSPEED));
}
}
expired += dt;
}
void RendererTestApp::setup()
{
mRenderFunctions = {
{ "Batch 2d", [=](){ mRenderer2dStrip.update(); mRenderer2dStrip.render(); } },
{ "VBO 2d", [=](){ mRenderer2dStripVbo.update(); mRenderer2dStripVbo.render(); } },
{ "Simple", [=](){ mSimpleRenderer.render(); } },
{ "Batch 2d (no updates)", [=](){ mRenderer2dStrip.render(); } },
{ "VBO 2d (no updates)", [=](){ mRenderer2dStripVbo.render(); } },
};
mRenderFn = mRenderFunctions.begin();
gl::enableVerticalSync();
Rand r;
for( auto &box : mBoxes )
{
box.setColor( ColorA{ CM_HSV, r.nextFloat( 1.0f ), 0.9f, 0.9f, 1.0f } );
box.setPos( Vec2f{ r.nextFloat(getWindowWidth()), r.nextFloat(getWindowHeight()) } );
box.setRotation( r.nextFloat( M_PI * 2 ) );
mRenderer2dStrip.add( &box );
mSimpleRenderer.add( &box );
mRenderer2dStripVbo.add( &box );
}
// We perform the cast since we know what type of things we stored in each renderer
// A type-safe way could be to assign y to each objects layer and then sort by layer
Vec2f center = getWindowCenter();
auto vortex_simple = [center]( const SimpleRenderer::Renderable *lhs, const SimpleRenderer::Renderable *rhs )
{
return static_cast<const Box*>( lhs )->getPos().distance(center) <
static_cast<const Box*>( rhs )->getPos().distance(center);
};
auto vortex_triangle = [center]( const BatchRenderer2d::Renderable *lhs, const BatchRenderer2d::Renderable *rhs )
{
return static_cast<const Box*>( lhs )->getPos().distance(center) <
static_cast<const Box*>( rhs )->getPos().distance(center);
};
mSimpleRenderer.sort( vortex_simple );
mRenderer2dStrip.sort( vortex_triangle );
mRenderer2dStripVbo.sort( vortex_triangle );
getWindow()->getSignalKeyUp().connect( [this](KeyEvent &event){ if( event.getCode() == KeyEvent::KEY_SPACE ){ swapRenderer(); } } );
getWindow()->getSignalTouchesEnded().connect( [this](TouchEvent &event){ swapRenderer(); } );
}
void MPEBouncingBallApp::mpeReset()
{
console() << "RESETTING\n";
// Set the random seed to a known value so all of the clients are using the same rand values.
mRand.seed(1);
// Clear out the previous state
mServerFramesProcessed = 0;
mBalls.clear();
// Add the first ball
ivec2 sizeMaster = mClient->getMasterSize();
addBallAtPosition(vec2(mRand.nextFloat(sizeMaster.x), mRand.nextFloat(sizeMaster.y)));
if (mClient->isAsynchronousClient())
{
send3DSettings();
}
}
void CristalWaveApp::setup()
{
float sizeW = getWindowWidth() * 0.5f;
float sizeH = getWindowHeight() * 0.5f;
float x = 0.0f,
z = 0.0f,
y = 0.0f;
/////////////////////////////////////////////////
int numRows = PARAM_WAVE_NB_ROWS;
int gap = PARAM_WAVE_GAP + getWindowWidth() / 2000;
int numLines = getWindowWidth() / gap + 1;
/////////////////////////////////////////////////
mOpacity = 0.0f;
mOffsetCameratH = 60; // Global amplitude
// Init BackgroundLayer
mBackground.setup(getWindowWidth(), getWindowHeight(), mOffsetCameratH);
// Init Wave Model
mWave.setup(getWindowWidth(), getWindowHeight(), numRows, numLines, -mOffsetCameratH);
// set a random offset
Rand rnd;
rnd.seed((unsigned long)GetTickCount());
mOffsetTime = rnd.nextFloat(0.0f, 100.0f);
// Set the Shader program
mFresnelShader.load();
mpWaveShader = &mFresnelShader;
mWave.setShader(mpWaveShader);
// --------------------------------------------------------
// Set Particule manager
int nbParticule = PARAM_NB_PARTICULES;
mEmitter.radius = PARAM_EMITTER_RADIUS;
mParticuleInTheWindManager.attrPosition = Vec3f::zero();
mParticuleInTheWindManager.attrFactor = PARAM_FORCE_FACTOR;
ParticuleManager::PARTICULE_LIFE particule_life;
particule_life.minTTL = 0.5f;
particule_life.maxTTL = 3.5f;
particule_life.minTTH = 1.0f;
particule_life.minTTH = 4.0f;
mParticuleInTheWindManager.init(nbParticule, particule_life, getWindowWidth());
}
Particle::Particle( const Vec2f& origin, Rand& random )
: position( origin ),
velocity( random.nextFloat( -1.0f, 1.0f ), random.nextFloat( -1.0f, 1.0f ) ),
acceleration( Vec2f::zero() ),
lifespan( 1.0f ),
aging( random.nextFloat( ( 1.0f / 100 ), ( 1.0f / 200 ) ) ),
sizeRadius( random.nextFloat( 2.0f, 7.0f ) ),
rotation( random.nextFloat( 0.0f, 360.0f ) ),
rotationSpeed( random.nextFloat( -5.0f, 5.0f ) ),
bounds( -sizeRadius, -sizeRadius, sizeRadius, sizeRadius )
{
sizeRadius /= 2.0f; // since the bounds are set, we update sizeRadius for drawing circles on our particles - see draw()
}
void MPEBouncingBallApp::addBallAtPosition(const vec2 & posBall)
{
ivec2 sizeMaster = mClient->getMasterSize();
vec2 velBall = vec2(mRand.nextFloat(-5,5), mRand.nextFloat(-5,5));
mBalls.push_back(Ball(posBall, velBall, sizeMaster));
}
void StereoscopicRenderingApp::render()
{
float seconds = (float) getElapsedSeconds();
// enable 3D rendering
gl::enableDepthRead();
gl::enableDepthWrite();
// set 3D camera matrices
gl::pushMatrices();
gl::setMatrices( mCamera );
if( mShaderPhong && mMeshTrombone && mMeshNote ) {
// enable phong shading
mShaderPhong.bind();
// draw trombone
gl::pushModelView();
{
gl::color( Color(0.7f, 0.6f, 0.0f) );
gl::rotate( Vec3f::yAxis() * 10.0f * seconds );
gl::draw( mMeshTrombone );
// reflection
gl::scale( 1.0f, -1.0f, 1.0f );
gl::draw( mMeshTrombone );
}
gl::popModelView();
// draw animated notes
Rand rnd;
for(int i=-100; i<=100; ++i) {
rnd.seed(i);
float t = rnd.nextFloat() * 200.0f + 2.0f * seconds;
float r = rnd.nextFloat() * 360.0f + 60.0f * seconds;
float z = fmodf( 5.0f * t, 200.0f ) - 100.0f;
gl::pushModelView();
{
gl::color( Color( CM_HSV, rnd.nextFloat(), 1.0f, 1.0f ) );
gl::pushModelView();
gl::translate( i * 0.5f, 0.15f + 1.0f * math<float>::abs( sinf(3.0f * t) ), -z );
gl::rotate( Vec3f::yAxis() * r );
gl::draw( mMeshNote );
gl::popModelView();
// reflection
gl::pushModelView();
gl::scale( 1.0f, -1.0f, 1.0f );
gl::translate( i * 0.5f, 0.15f + 1.0f * math<float>::abs( sinf(3.0f * t) ), -z );
gl::rotate( Vec3f::yAxis() * r );
gl::draw( mMeshNote );
gl::popModelView();
}
gl::popModelView();
}
mShaderPhong.unbind();
}
// draw grid
gl::color( Color(0.8f, 0.8f, 0.8f) );
for(int i=-100; i<=100; ++i) {
gl::drawLine( Vec3f((float) i, 0, -100), Vec3f((float) i, 0, 100) );
gl::drawLine( Vec3f(-100, 0, (float) i), Vec3f(100, 0, (float) i) );
}
// draw floor
gl::enableAlphaBlending();
gl::color( ColorA(1,1,1,0.75f) );
gl::drawCube( Vec3f(0.0f, -0.5f, 0.0f), Vec3f(200.0f, 1.0f, 200.0f) );
gl::disableAlphaBlending();
// restore 2D rendering
gl::popMatrices();
gl::disableDepthWrite();
gl::disableDepthRead();
// render UI
if( mDrawUI ) renderUI();
}
