public override void init()
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Cuerpo principal que se controla con el teclado
box = TgcBox.fromSize(new Vector3(0, 10, 0), new Vector3(10, 10, 10), Color.Blue);
//triangulo
triangle = new CustomVertex.PositionColored[3];
triangle[0] = new CustomVertex.PositionColored(-100, 0, 0, Color.Red.ToArgb());
triangle[1] = new CustomVertex.PositionColored(0, 0, 50, Color.Green.ToArgb());
triangle[2] = new CustomVertex.PositionColored(0, 100, 0, Color.Blue.ToArgb());
triagleAABB = TgcBoundingBox.computeFromPoints(new Vector3[] { triangle[0].Position, triangle[1].Position, triangle[2].Position });
//box2
box2 = TgcBox.fromSize(new Vector3(-50, 10, -20), new Vector3(15, 15, 15), Color.Violet);
//sphere
sphere = new TgcBoundingSphere(new Vector3(30, 20, -20), 15);
//OBB: computar OBB a partir del AABB del mesh.
TgcSceneLoader loader = new TgcSceneLoader();
TgcMesh meshObb = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\StarWars-ATST\\StarWars-ATST-TgcScene.xml").Meshes[0];
obb = TgcObb.computeFromAABB(meshObb.BoundingBox);
meshObb.dispose();
obb.move(new Vector3(100, 0, 30));
obb.setRotation(new Vector3(0, FastMath.PI / 4, 0));
//Configurar camara en Tercer Persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(box.Position, 30, -75);
}
public override void Init()
{
//Cuerpo principal que se controla con el teclado
box = TgcBox.fromSize(new Vector3(0, 10, 0), new Vector3(10, 10, 10), Color.Blue);
//triangulo
triangle = new CustomVertex.PositionColored[3];
triangle[0] = new CustomVertex.PositionColored(-100, 0, 0, Color.Red.ToArgb());
triangle[1] = new CustomVertex.PositionColored(0, 0, 50, Color.Green.ToArgb());
triangle[2] = new CustomVertex.PositionColored(0, 100, 0, Color.Blue.ToArgb());
triagleAABB =
TgcBoundingBox.computeFromPoints(new[]
{ triangle[0].Position, triangle[1].Position, triangle[2].Position });
//box2
box2 = TgcBox.fromSize(new Vector3(-50, 10, -20), new Vector3(15, 15, 15), Color.Violet);
//sphere
sphere = new TgcBoundingSphere(new Vector3(30, 20, -20), 15);
//OBB: computar OBB a partir del AABB del mesh.
var loader = new TgcSceneLoader();
var meshObb =
loader.loadSceneFromFile(MediaDir +
"MeshCreator\\Meshes\\Vehiculos\\StarWars-ATST\\StarWars-ATST-TgcScene.xml")
.Meshes[0];
obb = TgcObb.computeFromAABB(meshObb.BoundingBox);
meshObb.dispose();
obb.move(new Vector3(100, 0, 30));
obb.setRotation(new Vector3(0, FastMath.PI / 4, 0));
//Configurar camara en Tercer Persona
camaraInterna = new TgcThirdPersonCamera(box.Position, 30, -75);
Camara = camaraInterna;
}
public override void render(float elapsedTime)
{
motionBlurFlag = (bool)GuiController.Instance.Modifiers["motionBlurFlag"];
TgcTexture texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "TheC#\\Pista\\pistaCarreras.png");
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//pantalla De Inicio
if (flagInicio == 0)
{
//Actualizar valores cargados en modifiers
/*sprite.Position = (Vector2)GuiController.Instance.Modifiers["position"];
* sprite.Scaling = (Vector2)GuiController.Instance.Modifiers["scaling"];
* sprite.Rotation = FastMath.ToRad((float)GuiController.Instance.Modifiers["rotation"]);
*/
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
sprite.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
flagInicio = jugador.verSiAprietaSpace();
textIngreseTeclaSombra.render();
textIngreseTecla.render();
musica.verSiCambioMP3();
}
else
{
//Para contar el tiempo desde que preciona la barra espaciadora y comienza el juego
if (primerRenderDelJuegoAndando == true)
{
this.horaInicio = DateTime.Now;
primerRenderDelJuegoAndando = false;
}
//Todo lo referente a lo que debe hacer el IA
autoIA.elapsedTime = elapsedTime;
autoIA.establecerVelocidadMáximaEn((float)GuiController.Instance.Modifiers["velocidadMaxima"] * 1.02f);
if (colision.getTiempoQueChoco() == 0)
{
jugadorIA.jugar(trayectoDeIA[0].Center, meshAutoIA.Position);
}
meshAutoIA.Rotation = new Vector3(0f, autoIA.rotacion, 0f);
jugadorIA.setRotacion(meshAutoIA.Rotation);
meshAutoIA.moveOrientedY(-autoIA.velocidad * elapsedTime);
//Fin movimiento de auto IA
//Le paso el elapsed time al auto porque sus metodos no deben depender de los FPS
auto.elapsedTime = elapsedTime;
//Varío la velocidad Máxima del vehículo con el modifier "velocidadMáxima"
auto.establecerVelocidadMáximaEn((float)GuiController.Instance.Modifiers["velocidadMaxima"]);
//El jugador envia mensajes al auto dependiendo de que tecla presiono
//Se pone un tiempo para que luego de chocar 2 autos, estos no puedan ingresar movimiento (sólo se mueve por inercia)
if (colision.getTiempoQueChoco() == 0)
{
jugador.jugar(cantidadDeNitro);
}
else
{
colision.setTiempoQueChoco(colision.getTiempoQueChoco() - (8 * elapsedTime));
if (colision.getTiempoQueChoco() < 0)
{
colision.setTiempoQueChoco(0);
}
}
//Transfiero la rotacion del auto abstracto al mesh, y su obb
autoMesh.Rotation = new Vector3(0f, auto.rotacion, 0f);
oBBAuto.Center = autoMesh.Position;
oBBAuto.setRotation(autoMesh.Rotation);
meshAutoIA.Rotation = new Vector3(0f, autoIA.rotacion, 0f);
oBBAutoIa.Center = meshAutoIA.Position;
oBBAutoIa.setRotation(meshAutoIA.Rotation);
//Calculo de giro de la rueda
rotacionVertical -= auto.velocidad * elapsedTime / 60;
//Calculo el movimiento del mesh dependiendo de la velocidad del auto
autoMesh.moveOrientedY(-auto.velocidad * elapsedTime);
//Detección de colisiones
//Hubo colisión con un objeto. Guardar resultado y abortar loop.
//Si hubo alguna colisión, hacer esto:
if (huboColision(oBBAuto))
{
autoMesh.moveOrientedY(20 * auto.velocidad * elapsedTime); //Lo hago "como que rebote un poco" para no seguir colisionando
auto.velocidad = -(auto.velocidad * 0.3f); //Lo hago ir atrás un tercio de velocidad de choque
}
if (huboColision(oBBAutoIa))
{
meshAutoIA.moveOrientedY(20 * autoIA.velocidad * elapsedTime); //Lo hago "como que rebote un poco" para no seguir colisionando
autoIA.velocidad = -(autoIA.velocidad * 0.3f); //Lo hago ir atrás un tercio de velocidad de choque
}
//Colisión entre los autos
for (int i = 0; i < 4; i++)
{
float ro, alfa_rueda;
float posicion_xA1;
float posicion_yA1;
float posicion_xA2;
float posicion_yA2;
ro = FastMath.Sqrt(dx[i] * dxAColision[i] + dyAColision[i] * dyAColision[i]);
alfa_rueda = FastMath.Asin(dxAColision[i] / ro);
if (i == 0 || i == 2)
{
alfa_rueda += FastMath.PI;
}
posicion_xA1 = FastMath.Sin(alfa_rueda + auto.rotacion) * ro;
posicion_yA1 = FastMath.Cos(alfa_rueda + auto.rotacion) * ro;
posicion_xA2 = FastMath.Sin(alfa_rueda + autoIA.rotacion) * ro;
posicion_yA2 = FastMath.Cos(alfa_rueda + autoIA.rotacion) * ro;
obbsAuto[i].Position = (new Vector3(posicion_xA1, 15.5f, posicion_yA1) + autoMesh.Position);
obbsOtroAuto[i].Position = (new Vector3(posicion_xA2, 15.5f, posicion_yA2) + meshAutoIA.Position);
}
colision.colisionEntreAutos(obbsAuto, obbsOtroAuto, jugador, auto, autoIA, autoMesh, meshAutoIA, elapsedTime);
//Cosas sobre derrape
int direcGiroDerrape = 0;
if (auto.velocidad > 1500 && (jugador.estaGirandoDerecha() || jugador.estaGirandoIzquierda()))
{
if (jugador.estaGirandoIzquierda())
{
direcGiroDerrape = -1;
}
else if (jugador.estaGirandoDerecha())
{
direcGiroDerrape = 1;
}
autoMesh.Rotation = new Vector3(0f, auto.rotacion + (direcGiroDerrape * anguloDerrape), 0f);
oBBAuto.setRotation(new Vector3(autoMesh.Rotation.X, autoMesh.Rotation.Y + (direcGiroDerrape * anguloDerrape / 2), autoMesh.Rotation.Z));
if (anguloDerrape <= anguloMaximoDeDerrape)
{
anguloDerrape += velocidadDeDerrape * elapsedTime;
}
}
else
{
direcGiroDerrape = 0;
anguloDerrape = 0;
}
//Fin derrape
//Posiciono las ruedas
for (int i = 0; i < 4; i++)
{
float ro, alfa_rueda;
float posicion_x;
float posicion_y;
ro = FastMath.Sqrt(dx[i] * dx[i] + dy[i] * dy[i]);
alfa_rueda = FastMath.Asin(dx[i] / ro);
if (i == 0 || i == 2)
{
alfa_rueda += FastMath.PI;
}
posicion_x = FastMath.Sin(alfa_rueda + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * ro;
posicion_y = FastMath.Cos(alfa_rueda + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * ro;
ruedas[i].Position = (new Vector3(posicion_x, 15.5f, posicion_y) + autoMesh.Position);
//Si no aprieta para los costados, dejo la rueda derecha (por ahora, esto se puede modificar)
if (input.keyDown(Key.Left) || input.keyDown(Key.A) || input.keyDown(Key.Right) || input.keyDown(Key.D))
{
ruedas[i].Rotation = new Vector3(rotacionVertical, auto.rotacion + auto.rotarRueda(i) + (anguloDerrape * direcGiroDerrape), 0f);
}
else
{
ruedas[i].Rotation = new Vector3(rotacionVertical, auto.rotacion + (anguloDerrape * direcGiroDerrape), 0f);
}
}
//comienzo humo
float rohumo, alfa_humo;
float posicion_xhumo;
float posicion_yhumo;
rohumo = FastMath.Sqrt(-19f * -19f + 126f * 126f);
alfa_humo = FastMath.Asin(-19f / rohumo);
posicion_xhumo = FastMath.Sin(alfa_humo + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * rohumo;
posicion_yhumo = FastMath.Cos(alfa_humo + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * rohumo;
humo.Position = (new Vector3(posicion_xhumo, 15.5f, posicion_yhumo) + autoMesh.Position);
//Si no aprieta para los costados, dejo la rueda derecha (por ahora, esto se puede modificar)
if (input.keyDown(Key.Left) || input.keyDown(Key.A) || input.keyDown(Key.Right) || input.keyDown(Key.D))
{
humo.Rotation = new Vector3(0f, auto.rotacion + (anguloDerrape * direcGiroDerrape), 0f);
}
else
{
humo.Rotation = new Vector3(0f, auto.rotacion + (anguloDerrape * direcGiroDerrape), 0f);
}
//fin de humo
fuego.Position = humo.Position;
fuego.Rotation = humo.Rotation;
//fin fuego
cantidadDeNitro += 0.5f * elapsedTime;
cantidadDeNitro = FastMath.Min(cantidadDeNitro, 100f);
if (auto.nitro)
{
cantidadDeNitro -= 7 * elapsedTime;
cantidadDeNitro = FastMath.Max(cantidadDeNitro, 0f);
if (cantidadDeNitro > 1)
{
humo.Enabled = false;
fuego.Enabled = false;
}
}
else
{
humo.Enabled = false;
fuego.Enabled = false;
}
tiempoHumo += elapsedTime;
humo.UVOffset = new Vector2(0.9f, tiempoHumo);
humo.updateValues();
fuego.UVOffset = new Vector2(0.9f, tiempoHumo);
fuego.updateValues();
if (tiempoHumo > 50f)
{
tiempoHumo = 0f;
}
autoMeshPrevX = autoMesh.Position.X;
autoMeshPrevZ = autoMesh.Position.Z;
//Lineas de Frenado
if (jugador.estaFrenandoDeMano())
{
lineaDeFrenado[0].addTrack(new Vector3(ruedaDerechaDelanteraMesh.Position.X, 0, ruedaDerechaDelanteraMesh.Position.Z));
lineaDeFrenado[1].addTrack(new Vector3(ruedaDerechaTraseraMesh.Position.X, 0, ruedaDerechaTraseraMesh.Position.Z));
lineaDeFrenado[2].addTrack(new Vector3(ruedaIzquierdaDelanteraMesh.Position.X, 0, ruedaIzquierdaDelanteraMesh.Position.Z));
lineaDeFrenado[3].addTrack(new Vector3(ruedaIzquierdaTraseraMesh.Position.X, 0, ruedaIzquierdaTraseraMesh.Position.Z));
}
if (jugador.dejoDeFrenarDeMano())
{
for (int i = 0; i < lineaDeFrenado.Length; i++)
{
lineaDeFrenado[i].endTrack();
}
}
for (int i = 0; i < lineaDeFrenado.Length; i++)
{
lineaDeFrenado[i].render();
lineaDeFrenado[i].pasoDelTiempo(elapsedTime);
}
//Dibujo el reflejo de la luz en el auto
reflejo.Render();
//////Camara///////
if (jugador.estaMirandoHaciaAtras())
{
GuiController.Instance.ThirdPersonCamera.setCamera(autoMesh.Position, 200, -500);
GuiController.Instance.ThirdPersonCamera.Target = autoMesh.Position;
GuiController.Instance.ThirdPersonCamera.RotationY = auto.rotacion;
}
else
{
coheficienteCamara = jugador.verSiCambiaCamara();
GuiController.Instance.ThirdPersonCamera.setCamera(autoMesh.Position, 100 + (coheficienteCamara), 900 - (coheficienteCamara) * 4);
GuiController.Instance.ThirdPersonCamera.Target = autoMesh.Position;
GuiController.Instance.ThirdPersonCamera.RotationY = auto.rotacion;
}
//La camara no rota exactamente a la par del auto, hay un pequeño retraso
//GuiController.Instance.ThirdPersonCamera.RotationY += 5 * (auto.rotacion - prevCameraRotation) * elapsedTime;
//Ajusto la camara a menos de 360 porque voy a necesitar hacer calculos entre angulos
while (prevCameraRotation > 360)
{
prevCameraRotation -= 360;
}
prevCameraRotation = GuiController.Instance.ThirdPersonCamera.RotationY;
///////Musica/////////
jugador.verSiModificaMusica(musica);
//Dibujar objeto principal
//Siempre primero hacer todos los cálculos de lógica e input y luego al final dibujar todo (ciclo update-render)
foreach (TgcMesh mesh in scenePista.Meshes)
{
mesh.Enabled = (TgcCollisionUtils.classifyFrustumAABB(GuiController.Instance.Frustum, mesh.BoundingBox) != TgcCollisionUtils.FrustumResult.OUTSIDE);
}
if (motionBlurFlag)
{
motionBlur.update(elapsedTime);
motionBlur.motionBlurRender(elapsedTime, HighResolutionTimer.Instance.FramesPerSecond, auto.velocidad, 0);
}
else
{
foreach (TgcMesh mesh in scenePista.Meshes)
{
mesh.Technique = "DefaultTechnique";
mesh.render();
}
}
//Mostrar al auto IA
meshAutoIA.render();
//Muestro el punto siguiente
trayecto[0].render();
//mostrar el auto manejado por el humano
autoMesh.render();
for (int i = 0; i < 4; i++)
{
ruedas[i].render();
}
humo.render();
fuego.render();
//Colision con puntos de control, tanto de persona como IA
for (int i = 0; i < trayecto.Count; i++)
{
//Pregunto si colisiona con un punto de control activado. Lo sé, feo.
if ((i == 0) && TgcCollisionUtils.testPointCylinder(oBBAuto.Position, trayecto[i].BoundingCylinder))
{
TgcCylinder cilindroModificado = new TgcCylinder(trayecto[i].Center, 130, 30);
if (contadorDeActivacionesDePuntosDeControl != (posicionesPuntosDeControl.Count * 3))
{
trayecto.RemoveAt(i);
trayecto.Add(cilindroModificado);
contadorDeActivacionesDePuntosDeControl++;
textPuntosDeControlAlcanzados.Text = "Puntos De Control Alcanzados = " + contadorDeActivacionesDePuntosDeControl.ToString();
textTiempo.Text = (Convert.ToDouble(textTiempo.Text) + 3).ToString();
}
else
{
gano = true;
textGanaste.Text = "Ganaste y obtuviste un puntaje de " + textTiempo.Text + " puntos";
textGanaste.render();
auto.estatico();
//Para el IA
autoIA.estatico();
}
}
}
for (int i = 0; i < trayectoDeIA.Count; i++)
{
//Pregunto si colisiona con un punto de control activado
if ((i == 0) && TgcCollisionUtils.testPointCylinder(meshAutoIA.Position, trayectoDeIA[i].BoundingCylinder))
{
TgcCylinder cilindroModificado = new TgcCylinder(trayectoDeIA[i].Center, 130, 30);
if (contadorDeActivacionesDePuntosDeControlDeIA != (posicionesPuntosDeControlDeIA.Count * 3))
{
trayectoDeIA.RemoveAt(i);
trayectoDeIA.Add(cilindroModificado);
contadorDeActivacionesDePuntosDeControlDeIA++;
}
else
{
gano = true;
textGanaste.Text = "Ganó la máquina :P ";
textGanaste.render();
//Para el IA
autoIA.estatico();
auto.estatico();
}
}
}
textPosicionDelAutoActual.Text = autoMesh.Position.ToString();
//Renderizar los tres textos
textoVelocidad.mostrarVelocidad(auto.velocidad / 10).render(); //renderiza la velocidad
textPuntosDeControlAlcanzados.render();
textPosicionDelAutoActual.render();
//Cosas del tiempo
tiempo.incrementarTiempo(this, elapsedTime, (bool)GuiController.Instance.Modifiers["jugarConTiempo"]);
//Actualizo y dibujo el relops
if ((bool)GuiController.Instance.Modifiers["jugarConTiempo"])
{
if ((DateTime.Now.Subtract(this.horaInicio).TotalSeconds) > segundosAuxiliares)
{
if (Convert.ToDouble(textTiempo.Text) == 0)
{
textPerdiste.Text = "Perdiste y lograste " + contadorDeActivacionesDePuntosDeControl.ToString() + " puntos de control";
textPerdiste.render();
auto.estatico();
//Para el IA
autoIA.estatico();
}
else if (gano == true)
{
}
else
{
this.textTiempo.Text = (Convert.ToDouble(textTiempo.Text) - 1).ToString();
segundosAuxiliares++;
}
}
}
emisorHumo.update(elapsedTime, GuiController.Instance.CurrentCamera.getLookAt(), auto.rotacion, autoMesh.Position, anguloDerrape, direcGiroDerrape, auto.nitro && (cantidadDeNitro > 1), auto.velocidad);
emisorHumo.render(GuiController.Instance.CurrentCamera.getPosition());
textTiempo.render();
stringTiempo.render();
contadorDeFrames++;
hud.render(auto.velocidad, cantidadDeNitro);
}//cierra el if de que no esta en pantalla inicio
textFPS.Text = " FPS: " + HighResolutionTimer.Instance.FramesPerSecond.ToString();
textFPS.render();
}
public void deformarMesh(TgcObb obbColisionable, float velocidad)
{
object vertexBuffer = null;
Type tipo;
float distanciaMinima;
float factorChoque = Math.Abs(velocidad) * this.masa * 0.001F;
switch (this.mesh.RenderType)
{
case TgcMesh.MeshRenderType.VERTEX_COLOR:
vertexBuffer = (TgcSceneLoader.VertexColorVertex[]) this.mesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.VertexColorVertex), LockFlags.ReadOnly, this.mesh.D3dMesh.NumberVertices);
break;
case TgcMesh.MeshRenderType.DIFFUSE_MAP:
vertexBuffer = (TgcSceneLoader.DiffuseMapVertex[]) this.mesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapVertex), LockFlags.ReadOnly, this.mesh.D3dMesh.NumberVertices);
break;
case TgcMesh.MeshRenderType.DIFFUSE_MAP_AND_LIGHTMAP:
vertexBuffer = (TgcSceneLoader.DiffuseMapAndLightmapVertex[]) this.mesh.D3dMesh.LockVertexBuffer(
typeof(TgcSceneLoader.DiffuseMapAndLightmapVertex), LockFlags.ReadOnly, this.mesh.D3dMesh.NumberVertices);
break;
}
tipo = vertexBuffer.GetType();
System.Reflection.MethodInfo dameValorPorIndice = tipo.GetMethod("GetValue", new Type[] { typeof(int) });
System.Reflection.MethodInfo insertaValorPorIndice = tipo.GetMethod("SetValue", new Type[] { typeof(object), typeof(int) });
int cantidadDeVertices = (int)tipo.GetProperty("Length").GetValue(vertexBuffer, null);
//Calculo la distancia minima entre el centro del OBB colisionado y todos los vertices del mesh
//...parto con la distancia entre centros
distanciaMinima = (this.obb.Extents.Length() + obbColisionable.Extents.Length()) * 6;
this.puntoChoque = this.obb.Center;
Vector3[] cornersObbCoche = computeCorners(this.obb);
Vector3[] cornersObstaculo = computeCorners(obbColisionable);
int idPuntoChoque = 0;
for (int j = 0; j < 8; j++)
{
for (int i = 0; i < 8; i++)
{
if (distanciaMinimaAlPlano(cornersObbCoche[i], cornersObstaculo[j]) < distanciaMinima)
{
distanciaMinima = distanciaMinimaAlPlano(cornersObbCoche[i], cornersObstaculo[j]);
this.puntoChoque = cornersObbCoche[i]; // acá es donde se genera el choque!!! (es un corner del obb)
idPuntoChoque = i;
}
}
}
if (Shared.debugMode)
{
// ya sé donde se genera el choque... ahí voy a crear una esfera para verlo en el DebugMode
moon.Position = this.puntoChoque;
}
//Armo un obb auxiliar para rotarlo a la orientación original (porque el VertexBuffer me carga los vértices sin rotar!!!)
TgcObb obbAuxiliar = this.obb;
obbAuxiliar.setRotation(rotacionInicial);
Vector3[] nuevosCorners = computeCorners(obbAuxiliar);
Vector3 puntoChoqueDeformacion = nuevosCorners[idPuntoChoque];
// APLICO DEFORMACIÓN EN MALLA
/// .... mientras, aprovecho para buscar al verdadero punto de choque (el otro es un corner del obb)
distanciaMinima = (this.obb.Extents.Length() + obbColisionable.Extents.Length()) * 6;
Vector3 verdaderoPuntoDeChoque = puntoChoque; // lo voy a usar para las chispas!
for (int i = 0; i < cantidadDeVertices; i++)
{
object vertice = dameValorPorIndice.Invoke(vertexBuffer, new object[] { i });
Vector3 unVerticeDelMesh = (Vector3)vertice.GetType().GetField("Position").GetValue(vertice);
unVerticeDelMesh += this.obb.Position;
if (Math.Abs(distancePointPoint(unVerticeDelMesh, puntoChoqueDeformacion)) < distanciaMinima)
{
distanciaMinima = Math.Abs(distancePointPoint(unVerticeDelMesh, puntoChoqueDeformacion));
verdaderoPuntoDeChoque = unVerticeDelMesh;
}
/// voy tirando los vertices al centro del mesh
if (Math.Abs(distancePointPoint(unVerticeDelMesh, puntoChoqueDeformacion)) < factorChoque)
{
float factorDeformacion = factorChoque * 0.1f;
Vector3 vectorDondeMoverElPunto = unVerticeDelMesh - puntoChoqueDeformacion;
//vectorDondeMoverElPunto.Z = unVerticeDelMesh.Z; // fuerzo al plano Z para que no pasen cosas raras
//corro de lugar el vértice del mesh, usando el versor del vector
unVerticeDelMesh += factorDeformacion * Vector3.Normalize(vectorDondeMoverElPunto);
//restauro como estaba antes, sino guardo cqcosa
unVerticeDelMesh -= this.obb.Position;
vertice.GetType().GetField("Position").SetValue(vertice, unVerticeDelMesh);
insertaValorPorIndice.Invoke(vertexBuffer, new object[] { vertice, i });
}
}
this.mesh.D3dMesh.SetVertexBufferData(vertexBuffer, LockFlags.None);
this.mesh.D3dMesh.UnlockVertexBuffer();
// FIN DEFORMACIÓN
//Mientras más se deforma, más se reduce su velocidad máxima
this.velocidadMaxima -= factorChoque * 0.5f;
//Ahora vienen las CHISPAS
int k = 0;
int cte = chispas.Count * 4;
foreach (Chispa chispa in this.chispas)
{
chispa.mesh.Position = verdaderoPuntoDeChoque;
chispa.asignarDireccion(puntoChoque, verdaderoPuntoDeChoque, new Vector3(k * cte, k * cte, k * cte));
chispa.tiempoChispas = factorChoque * 5;
k++;
}
}
