Necesito mover el punto A hacia el punto B.
El movimiento a de ser constante en todo momento.
He probado la fórmula:
A += (distancia entre A y B) / Velocidad;
... y efectivamente A se dirije a B... pero va DECELERANDO conforme lo alcanza. Pero yo necesito un movimiento CONSTANTE.
¿Alguien tiene idea?
S2.
Veamos, e/v = t
Estas sumando cada vez el tiempo restante hasta el objetivo, que al ser cada vez menor, decelera.
Es tan simple como sumar un numero de pixels fijo cada vuelta de bucle.
Ej: A++, A+5, A+25
Saludos
A + t*(B-A) variando t en el intervalo [0,1] a la velocidad y con la uniformidad que quieras.
A y B puedes ser cualquier cosa que tenga suma, resta y producto por escalar definido, por ejemplo un vector 3d o 2d.
saludos
Lo que ocurre es que no normalizas el vector direccion BA
la ecuacion seria
nuevaPos = viejaPos + Normalizar(B-A)*Velocidad
Donde todos son vectores excepto velocidad q es un escalar.
"Normalizar(B-A)"
¿A que te refieres con normalizar?
S2.
Cita de: "J_F_NASH""Normalizar(B-A)"
¿A que te refieres con normalizar?
S2.
Si lo haces como te ha dicho ethernet (interpolación lineal) no hace falta normalizar, de lo contrario necesitarás una función como ésta para normalizar el vector cuyo origen es el punto A y destino es el punto B.
IFXVECTOR3* IFXVec3Normalize
( IFXVECTOR3 *pOut, const IFXVECTOR3 *pV )
{
float denom;
denom = sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
if (fabs(denom) < IFX_EPSILON) return NULL;
denom = 1.0f / denom;
pOut->x = pV->x * denom;
pOut->y = pV->y * denom;
pOut->z = pV->z * denom;
return pOut;
}Esa función normaliza un vector 3D, si fuera 2D sería igual pero quitando la componente Z.
Saludos.
PD: IFX_EPSILON sería un valor cercano a cero (yo lo tengo a 1e-5f) para evitar la división por 0.
He probado la fórmula de ethernet. Esto es lo que le indico a A:
A = A + 0.1*(B-A)
Pero ocurre lo de siempre, la velocidad de A va bajando hasta cero.
Imagino que en cada pasada debo cambiar el valor 0.1, pero no lo tengo nada claro.
¿Podeis poner un ejemplo SENCILLO?
S2.
Hay un error en lo que haces.
Guárdate la posición INICIAL de lo que quieres mover en la variable "posicion_inicial", por ejemplo.
y luego, en cada pasada haces:
posicion=posicion+0.1*(posicion_final - posicion_inicial)
En la primera pasada:
pasitoPalanteMaria = (B-A) / longitudZancada
A = A + PasitoPalanteMaria
En las demas pasadas:
A = A + PasitoPalanteMaria
...donde longitudZancada es la distancia a cubrir en 1 unidad de tiempo. Realmente deberias usar
A = A + (PasitoPalanteMaria * ajusteFPS)
donde ajusteFPS está entre 0 y 1 y representa cuanto tiempo ha pasado desde la ultima pasada, dependiento de la velocidad de proceso
Que complicado!
Me parece que te hace falta mas base matematica, aqui te han dado mas de 3 soluciones, ahora te toca a ti estudiarlas por tu cuenta.
La error mas grave esta en el uso de la funcion acumulador, los mas facil es usar velocidad como vector y punto.
v = (B - A) / iteraciones; // de ahora en mas V no se toca mas
dibujar_punto(A); // inicial
for(int i=0; i<iteraciones; i++)
{
A += V;
dibujar_punto(A);
}
al terminar el bucle A sera igual a B
Saludos
yo lo veo simple la idea seria V=Normalize(D)*Rapidez/tiempo
D=B-A
y que mas?
si el pto se mueve pues vuelves a normalizar D y listo
Ok, gracias por todas las explicaciones. Ahora si.
S2.