• Create Account

Banner advertising on our site currently available from just \$5!

# razaron

Member Since 09 Aug 2011
Offline Last Active Jul 07 2012 10:39 AM

### Separating axis theorem

23 January 2012 - 10:04 AM

I'm having trouble implementing the separating axis theorem. If I do the calculation in the code on paper it works, however if I run the code it doesn't.

The aabb part is for (later) optimization.

Here are the relevant bits of code:
Projection Class,
```public class Projection {
protected double min;
protected double max;

public Projection(double min, double max){
min=this.min;
max=this.max;
}

public boolean overlap(Projection p2){
boolean temp=true;

if(min>p2.max || max<p2.min)
temp=false;

return temp;
}
}
```

Collision Detection part of the polygon (convex) class,
```		public boolean collides(Polygon poly){
boolean check = true;
double temp=0;
Projection p1;
Projection p2;
Point2D.Double axis;

for(int i=0;i<edges;i++){
if(check){
double min=0,max=0;
double dx=edge[i].v2.pos.x - edge[i].v1.pos.x;
double dy=edge[i].v2.pos.y - edge[i].v1.pos.y;

double x=(dx)/Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
double y=(dy)/Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
axis = new Point2D.Double(-x, y);

min = max = (axis.x*vertex[0].pos.x)+(axis.y*vertex[0].pos.y);

//project this shape
for(int j=0;j<vertices;j++){
temp= (axis.x*vertex[j].pos.x)+(axis.y*vertex[j].pos.y);
if(temp<min)
min=temp;
if(temp>max)
max=temp;
}
p1 = new Projection(min,max);

min = max = (axis.x*poly.vertex[0].pos.x)+(axis.y*poly.vertex[0].pos.y);
//project other shape
for(int j=0;j<poly.vertices;j++){
temp= (axis.x*poly.vertex[j].pos.x)+(axis.y*poly.vertex[j].pos.y);
if(temp<min)
min=temp;
if(temp>max)
max=temp;
}
p2 = new Projection(min,max);

if(!p1.overlap(p2))
check=false;
}
}

return check;
}
```

The implementation in the main class (done every frame),
```				polygon.elementAt(j).aabbCollision=false;
polygon.elementAt(j).polyCollision=false;
for(int l=0;l<polygon.capacity();l++){
if(l!=j){
if(polygon.elementAt(j).box.compareAABB(polygon.elementAt(l).box)){
polygon.elementAt(j).aabbCollision=true;
}
if(polygon.elementAt(j).collides(polygon.elementAt(l))){
if(polygon.elementAt(l).collides(polygon.elementAt(j))){
polygon.elementAt(j).polyCollision=true;
}
}
}
}
```

### Verlet particle sytem not working

13 January 2012 - 01:23 PM

I've a very basic particle system based on verlet intergration. It seems fine but the updateVerlet() function returns a nullpointer exception. I just can't find the problem.
Here's the source (exluding imports):

Main class,
```public class ParticleSystem {
int lastFrame, width=800, height=600;
boolean simulating;
int ticker;

Vertex[] vertex = new Vertex[100];
int temp;

public void Start(){

try {
Display.setDisplayMode(new DisplayMode(width,height));
Display.create();
} catch (LWJGLException e) {
e.printStackTrace();
System.exit(0);
}

initGL();

getDelta();
boolean Close = Display.isCloseRequested();

while(!Close){
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

int delta=getDelta();
ticker+=delta;

if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE) || Display.isCloseRequested())
Close = true;

if(Keyboard.isKeyDown(Keyboard.KEY_RETURN))
simulating = true;

if(temp <100 && Mouse.isButtonDown(0) && ticker>=100){
vertex[temp]= new Vertex(Mouse.getX(), height-Mouse.getY());
temp++;
ticker=0;
}

if(simulating)
logic(delta);
renderer();

Display.update();
}

}

public void logic(int delta){
for(int i=0;i<temp;i++){
vertex[i].updateVerlet(delta);
}
}

public void renderer(){
for(int i=0;i<100;i++){
if(vertex[i]!=null)
vertex[i].draw();
}
}

public int getDelta(){
long time = getTime();
int delta = (int) (time - lastFrame);
lastFrame = (int) time;

return delta;
}

public long getTime(){
return (Sys.getTime()*1000)/Sys.getTimerResolution();
}

public void initGL(){
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glOrtho(0, width, height, 0, 1, -1);
GL11.glMatrixMode(GL11.GL_MODELVIEW);
}
public static void main(String args[]){
ParticleSystem ps = new ParticleSystem();
ps.Start();
}
}
```

Vertex class,
```public class Vertex {
protected Point2D.Double pos;
protected Point2D.Double oldpos;
protected Point2D.Double acceleration;
protected Point2D.Double temp;

public Vertex(double x, double y){
pos = new Point2D.Double(x,y);
oldpos = new Point2D.Double(x,y);
}

public void updateVerlet(int delta){
double t=((double)delta)/1000;
temp.x=pos.x;
temp.y=pos.y;

pos.x += (pos.x - oldpos.x) + (acceleration.x*t*t);
pos.y += (pos.y - oldpos.y) + (acceleration.y*t*t);

oldpos.x=temp.x;
oldpos.y=temp.y;
}

public void draw(){
GL11.glColor3f(1f, 0f, 0f);