dist calculations

[Scorpious2k]

Took a little time to look at the dist calcs... in Mob:ist it reads

float Mob::Dist(const Mob &other) {
    double xDiff = other.x_pos - x_pos; 	
     double yDiff = other.y_pos - y_pos; 	
     double zDiff = other.z_pos - z_pos;
     return sqrt( (xDiff * xDiff) 
 	           + (yDiff * yDiff)
                     + (zDiff * zDiff) ); 
}

Which looks about as efficient as you can get without going to assembler... but if you went to that level it might look like

float Mob::Dist(const Mob &other) 
{ 	
         double xDiff = other.x_pos - x_pos;
 	double yDiff = other.y_pos - y_pos;
 	double zDiff = other.z_pos - z_pos;
	double calctemp;
	float calcdist;

	__asm 
	{
		fld	xDiff
		fmul	xDiff
		fst	calctemp
		fld	yDiff
		fmul	yDiff
		fadd	calctemp
		fst	calctemp
		fld	zDiff
		fmul	zDiff
		fadd	calctemp
		fsqrt
		fst	calcdist
	}
	return calcdist;
}

Which might run in under 500 cycles....

Haven't tested this mind you, just a thought

[DannMann99]

Not to get off topic but... i love the sig lol... kind of like the saying:
"I am a compulsive liar". Makes you wonder.

About the code, you should compile it and see what happens.
~Dan

[Scorpious2k]

Originally Posted by DannMann99

i love the sig lol...

Thanks, it fits if you know me.

About the code, you should compile it and see what happens.

I compiled it to check and see that it was clean, but we aren't running 5.0 at the moment so I have no way to test it. I wrote it sort of off the top of my head, so I'm not positive its exactly right.

I know that Trumpcard is looking for something like this and thought I would toss it out. If it works well enough, I'll do the rest of the dist calcs if he wants.

[Mongrel]

Why use doubles? I doubt we need 64 bit accuracy anyway, so unless someone is running a 64 bit server, floats are 2x faster and use half the memory space.

[Trumpcard]

You're right, those should be floats...

The original programmer put them in as doubles, we've just never gone back around to fixing it...

Good catch on that, didnt even notice it.. I'll fix those in CVS tonight.

[Scorpious2k]

At the assembly level, it doesn't seem to make a difference since they are all converted to 80 bit values on load. And I don't see a difference in the timing in it either.

I still agree the precision should be only what is needed because it creates overhead to convert in C++.

[Eglin]

It is usually better to calculate distance squared, since you eliminate the root op.

Originally Posted by Scorpious2k

Took a little time to look at the dist calcs... in Mob::Dist it reads

float Mob::Dist(const Mob &other) {
    double xDiff = other.x_pos - x_pos; 	
     double yDiff = other.y_pos - y_pos; 	
     double zDiff = other.z_pos - z_pos;
     return sqrt( (xDiff * xDiff) 
 	           + (yDiff * yDiff)
                     + (zDiff * zDiff) ); 
}

Which looks about as efficient as you can get without going to assembler... but if you went to that level it might look like
...<snip>...

[kathgar]

Thats what DistNoRoot and DistNoRootNoZ are for