saulotmalo escribió:esta noche te envio al privado una copia del codigo ( quiero privacidad hasta que lo releasee y me fio de ti ;) ) te ordenaré un poco el código que ahora mismo solo lo leo yo xD.
ah si por cierto aabb aligned axis bounding box. toma nombre... por cierto en teoría las colisiones ya lo verás pero las debería detectar el propio motor pero pasa de mi... :( en fin ya te lo enseñaré creo que lo que me dijiste de la precision puede tener que ver, ya que siempre pasa en los límites, intentaré habilitar algún tipo de traza para que te sea más fácil... pero no te prometo nada :(
y muchas gracias por la ayuda!!!!! :)
Okis.
Entonces la deteccion es muy facil, ya que realmente, estas haciendo lo que yo te decia que hicieras, solo que la 'bola' en vez de usar el volumen esferico, es mas sencillo usar puntos estrategicamente situados en la superficie y comprobar que quedan dentro de las cajas.
Yo mi idea del tipo de deteccion que me gustaria hacer, se basa en construir objetos utilizando una unidad de volumen relativamente sencilla, que me permite obtener un plano que representa un corte en seccion de la pieza (que seria un triangulo o dos ) y terminar comparando si dos triangulos colisionan en un espacio 2D.
Hace muchos años estuve trabajando en algo como esto, pero lo acabe dejando y ahora no poseo el codigo fuente :S .
Lo mas complejo, es que partiendo de un plano, hay que crear una matriz de transformacion que alinee ese plano con alguno de los ejes, para luego aplicarla sobre las piezas de volumen a comparar y poder cortarlas en seccion al pasar por ese plano y que te cree una superfice en 2D para comparar.
Como puedes ver, suena un tanto complejo, pero lo interesante es que no tiene por que ser lento y se pueden meter por medio algunas comprobaciones rapidas para evitar hacer calculos inutiles.
Para comprobar colisiones en objetos 3D, se puede recurrir a comprobar si un triangulo toca la "piel" de otro objeto, pero nunca te dira si estas dentro de el, a menos que tu hayas construido el objeto de forma que tengas alguna referencia volumetrica.
Yo lo que hacia es construir volumenes usando unas piezas elementales que me permitian cosntruir objetos torno o extruidos de una forma sencilla.
¿Para que usaba yo esto? Pues... para poder restar o sumar objetos, añadiendo o quitando la "piel" que hiciera falta ;)
EDITADO:
He creado dos rutinas, una para detectar la colision de dos cajas (la bola estaria dentro de una caja tambien) y otra para detectar si unpunto esta dentro de una caja (esta se puede utilizar para afinar las detecciones aun mas)
La cajas estaran alineadas a lo ejes universales y por eso solo requieren el punto central del objeto y el ancho,alto, fondo de la caja.
// TestBoxes: compara si dos cajas colisionan
// x1,y1,z1 -> posicion espacial de box 1
// dx1,dy1,dz1-> ancho,alto,fondo de box 1
// x2,y2,z2 -> posicion espacial de box 2
// dx2,dy2,dz2-> ancho,alto,fondo de box 2
// retorno: 1 si hay colision y 0 si no la hay
int TestBoxes(float x1,float y1,float z1,float dx1,float dy1,float dz1,float x2,float y2,float z2,float dx2,float dy2,float dz2)
{
int f;
float ax1,ay1,az1,ax2,ay2,az2;
float bx1,by1,bz1,bx2,by2,bz2;
// obtiene coordenadas de comparacion de las cajas
ax1=x1-(dx1/2.0f);
ax2=ax1+dx1;
ay1=y1-(dy1/2.0f);
ay2=ay1+dy1;
az1=z1-(dz1/2.0f);
az2=az1+dz1;
bx1=x2-(dx2/2.0f);
bx2=bx1+dx2;
by1=y2-(dy2/2.0f);
by2=by1+dy2;
bz1=z2-(dz2/2.0f);
bz2=bz1+dz2;
f=0;
if((ax1>=bx1 && ax1<=bx2) || (ax2>=bx1 && ax2<=bx2) ||
(bx1>=ax1 && bx1<=ax2) || (bx2>=ax1 && bx2<=ax2)) f=1; // las x se cruzan
if(f==1)
{
if((ay1>=by1 && ay1<=by2) || (ay2>=by1 && ay2<=by2) ||
(by1>=ay1 && by1<=ay2) || (by2>=ay1 && by2<=ay2)) f=2; // las y se cruzan
}
if(f==2)
{
if((az1>=bz1 && az1<=bz2) || (az2>=bz1 && az2<=bz2) ||
(bz1>=az1 && bz1<=az2) || (bz2>=az1 && bz2<=az2)) f=3; // las z se cruzan
}
if(f==3) return 1; // hay colision
return 0; // no hay colision
}
// TestPointInBox: compara si un punto esta dentro de la caja
// x1,y1,z1 -> posicion espacial del punto a comprobar
// x2,y2,z2 -> posicion espacial del box
// dx2,dy2,dz2-> ancho,alto,fondo del box
// retorno: 1 si elpunto esta dentro del box y 0 si no lo está
int TestPointInBox(float x1,float y1,float z1,float x2,float y2,float z2,float dx2,float dy2,float dz2)
{
float bx1,by1,bz1,bx2,by2,bz2;
// obtiene coordenadas de comparacion de la caja
bx1=x2-(dx2/2.0f);
bx2=bx1+dx2;
by1=y2-(dy2/2.0f);
by2=by1+dy2;
bz1=z2-(dz2/2.0f);
bz2=bz1+dz2;
if((x1>=bx1 && x1<=bx2) && (y1>=by1 && y1<=by2) && (z1>=bz1 && z1<=bz2)) return 1; // el punto esta dentro de la caja
return 0;// el punto no esta dentro de la caja
}
Estas funciones, te tienen trabajar, pero recuerda lo que te he dicho por MP, que estas rutinas detectaran solo si hay colision o no y luego deberias interpolar la posicion, desde la actual hasta la antigua usando un paso mas fino, hasta que la bola quede fuera del objeto, si quieres dibujarla sin que atraviese el ladrillo.
Sobre las reglas de rebote, la primera regla es que en principio, si la bola va hacia adelante y se topa con un obstaculo de frente, sale rebotada hacia atras y en principio, salvo que algo se oponga, conserva el mismo movimiento lateral y en tu caso, vertical.
Para saber si debes cambiar el sentido del desplazamiento lateral, puedes usar muchos trucos, trabajando de igual forma que si lo hicieras en 2D.
Tus piezas estan todas distribuidas en un panel a una distancia que tu conoces y puedes saber con calculos muy sencillos, si la bola ha chocado con un objeto que esta en frente o lateralmente, pero te recomiendo que antes de corregir el angulo de desplazamiento de la bola, corrijas la posicion de esta interpolando pasos entre la posicion moderna y la antigua, de forma fina, hasta que no se produzca colision con el ladrillo detectado.
Entonces, te costara menos determinar el angulo de rebote, porque por ejemplo, si en esa posicion corregida ves que tienes un ladrillo justo arriba de la bola y otro justo a la izquierda de la bola, pues ya sabes que el rebote será hacia adelante y a la derecha.
Lo mismo se aplicaria par los ladrillos que esten encima y debajo, claro: solo es cuestion de dividir el espacio 3D en dos vistas en 2D y trabajar a partir de ellas.
)
) te ordenaré un poco el código que ahora mismo solo lo leo yo xD.
en fin ya te lo enseñaré creo que lo que me dijiste de la precision puede tener que ver, ya que siempre pasa en los límites, intentaré habilitar algún tipo de traza para que te sea más fácil... pero no te prometo nada 
![[burla2]](/images/smilies/nuevos/burla_ani1.gif "burla2")
(yo solo he visto metodos basados en esferas y eso no me interesa para lo que quiero hacer) ![[Ooooo]](/images/smilies/nuevos/sorprendido_ani1.gif "Oooooo")
. ![[+risas]](/images/smilies/nuevos/risa_ani3.gif "más risas")
