DrawLines Performance « cocos2d for iPhone

cocos2d for iPhone » Programming » cocos2d support (graphics engine)

DrawLines Performance

(9 posts) (6 voices)

Started 2 years ago by mattiasmak
Latest reply from CJ

Tags:

mattiasmak
Member

Hi!

I'm doing a particle engine for our next project. The engine is at the moment just drawing lines, but the performance is not very good I think. At least not when comparing to geoDefence. I get framerates around 20fps with more than 1000 particles. However, I don't know if I'm totally off route somewhere. Hope that someone here can help me a bit. I'm thinking about c-arrays intead of nsmutablearray. But I don't know if it will help that much. Perhaps the bottleneck if obvious for some of you?

I've cut down the code to the basic core. tickParticles is called each tick. (30 times/sec)
-(void) tickParticles{
availableVerts = 0; v = 0; for (LineParticle *p in Particles) { if( ccpLengthSQ(p.Velocity) >= 0.5 ){ p.Velocity = ccpMult(p.Velocity, 0.95); [p setPosition: ccpAdd(p.Position, p.Velocity)]; verts[v++] = p.Position.x; verts[v++] = p.Position.y; verts[v++] = p.Position.x+p.Velocity.x*1.8; verts[v++] = p.Position.y+p.Velocity.y*1.8; availableVerts += 2; } } } -(void)draw{ glColor4ub(100, 255, 100, 180); drawLines( verts, Nil, availableVerts); } void drawLines( GLfloat *vertices, GLubyte *colors, unsigned int numberOfPoints ) { glVertexPointer(2, GL_FLOAT, 0, vertices); glEnableClientState(GL_VERTEX_ARRAY); glDrawArrays(GL_LINES, 0, numberOfPoints); glDisableClientState(GL_VERTEX_ARRAY);
}

Posted 2 years ago #
smooth
Member

1. Cocos2d allready has a particle generator (see particlesystem class and its derivatives)
2. drawLines and draw method looks ok
3. 1000 lines should not be a problem ( i draw like 2K or 3k of them and it works smooth, but they are very short)
4. Objective-C is SLOW. Try not to use its collections and iterators. Use classic C instead (where there is a lot of looping). Your tickParticles code is BAAD, rewrite it to classic C (or C++). You can also use static inline methods because they are like macros and are replaced when compiled with function implementation.
5. Use X-code instruments to find your bottlenecks

Posted 2 years ago #
mattiasmak
Member

I totally rewrote the whole thing, just using arrays of GLfloats for holding positions, velocities, colors.... The performance is outstanding! I can easily have several thousands of particles with almost no fps loss.

Thanks!

Posted 2 years ago #
onedayitwillmake
Member

Could you share some more info on what your end result code looks like?
It might help others

Oneday,
http://littlephysics.com

Posted 2 years ago #

mattiasmak
Member

Well. It's extremely basic, but gives a great result/performance. It's very much like geoDefence, but I'm gonna work with it to stand out from it. This was just a first step for me. I have a short video of it in action and the code is below.

-(id) init{
    self = [super init];
    if (self != nil) {

		for(int i=0;i<NumberOfParticles;i+=2){

			// Set all particles to zero
			positions[i] = 0.0;
			positions[i+1] = 0.0;			

			velocities[i] = 0.0;
			velocities[i+1] = 0.0;

		}

    }
    return self;
}

-(void) ExplodeAtPosition: (CGPoint)WhatPoint Amount:(int)Amount{
	float speed;
	float angle;
	int howmany = 0;

	for(int i=0;i<NumberOfParticles;i+=2){		

		// If velocity < 0.5 then reuse this particle
		if(sqrt(pow(velocities[i],2)+pow(velocities[i+1],2)) < 0.5){
			// Set position
			positions[i] = WhatPoint.x;
			positions[i+1] = WhatPoint.y;

			// Set random speed and angle
			speed = (arc4random() % 170)/10.0;
			angle = (arc4random() % 150)/10.0;
			velocities[i] = speed*cos(angle);
			velocities[i+1] = speed*sin(angle);

			// If enough particles are inited, then exit.
			if(howmany++>=Amount) return;

		}

	}

}

-(void) tickParticles{

	availableVerts = 0;
	v = 0;	

	for(int i=0;i<NumberOfParticles;i+=2){		

		// If particles have speed over 0.5 (active), move them.
		if(sqrt(pow(velocities[i],2)+pow(velocities[i+1],2)) >= 0.5){

			// Bounce of walls
			if (positions[i]>=480 || positions[i]<=0){
				velocities[i] = -velocities[i];
			}
			if (positions[i+1]>=320 || positions[i+1]<=0){
				velocities[i+1] = -velocities[i+1];
			}

			// Acceleration
			velocities[i]*=0.95;
			velocities[i+1]*=0.95;	

			// Add velocity to position
			positions[i] += velocities[i];
			positions[i+1] += velocities[i+1];

			// Load draw data
			verts[v++] = positions[i];
			verts[v++] = positions[i+1];
			verts[v++] = positions[i]+velocities[i]*1.8;
			verts[v++] = positions[i+1]+velocities[i+1]*1.8;

			// Amount to draw
			availableVerts++;			

		}

	}

}

-(void)draw{	

	glColor4ub(100, 255, 100, 150);
	drawLines( verts, Nil, availableVerts*2 );

}

void drawLines( GLfloat *vertices, GLubyte *colors, unsigned int numberOfPoints )
{

	int blendDst;
	int blendSrc;

	glGetIntegerv(GL_BLEND_DST, &blendDst);
	glGetIntegerv(GL_BLEND_SRC, &blendSrc);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glEnableClientState(GL_VERTEX_ARRAY);

	glDrawArrays(GL_LINES, 0, numberOfPoints);

	glDisableClientState(GL_VERTEX_ARRAY);

	glBlendFunc( blendSrc, blendDst );

}

Posted 2 years ago #

mattiasmak
Member

Hello there all experienced! As a newbie I have one more question. Now when the performance of the particles is great, I notice a small delay when an explosion is trigging. It's when ExplodeAtPosition is called with 500 particles. I guess that sqrt, arc4random(), sin and cos is time consuming.

What is the opinion about math functions. Should I avoid these as long as posible?

Posted 2 years ago #
michaelm
Member

So the line if(sqrt(pow(velocities[i],2)+pow(velocities[i+1],2)) < 0.5) just calculates the difference in velocities between two particles. couldn't you just use something like
if (abs(velocities[i]-velocities[i+1]) < ?) just play around with the number where the question mark is to get a good approximation of what you want.

Save you the overhead of two pows and a sqrt, with thousand particles thats a pretty good hit.

Posted 2 years ago #
mhussa
Member

@michaelm

I think its calculating the distance from the origin (0,0), so i is Xvelocity and i+1 is Yvelocity.

so should it be '>'?

if (abs(velocities[i]-velocities[i+1]) > (0.5*0.5) )

Posted 2 years ago #
CJ
Moderator

@mattiasmak it's looking pretty good.
I think you can get a bit more out of it by using float math instead of double math... replace the following:
sqrt(), pow(), cos(), sin()
with:
sqrtf(), powf(), cosf(), sinf()

And of course (like others suggested) if you can avoid doing square root altogether, it's faster too.

Posted 2 years ago #

RSS feed for this topic

Reply

You must log in to post.