public Vector3 calculoNormalPared(TgcMesh mesh)
{
Vector3 punto1 = mesh.getVertexPositions()[0];
Vector3 punto2 = mesh.getVertexPositions()[1];
Vector3 punto3 = mesh.getVertexPositions()[2];
Vector3 vectorDir1 = punto2 - punto1;
Vector3 vectorDir2 = punto3 - punto1;
Vector3 normalPared = Vector3.Cross(vectorDir1, vectorDir2);
return(normalPared);
}
/// <summary>
/// Crea un BoundingSphere a partir de los vertices de un Mesh, utilizando el algoritmo de Ritter
/// </summary>
/// <param name="mesh">Mesh a partir del cual crear el BoundingSphere</param>
/// <returns>BoundingSphere creado</returns>
public static TgcBoundingSphere computeFromMesh(TgcMesh mesh)
{
var vertices = mesh.getVertexPositions();
var s = computeFromPoints(vertices);
return(s.toClass());
}
public Boolean interseccionRayoPlano(Vector3 Origen, Vector3 Destino, TgcMesh mesh, out Vector3 salida)
{
Vector3 normalPared = calculoNormalPared(mesh);
Vector3 puntoPared = mesh.getVertexPositions()[0];
Vector3 calculo1 = puntoPared - Origen;
Vector3 calculo2 = Destino - Origen;
if (Vector3.Dot(normalPared, calculo2) == 0)
{
salida = new Vector3(0, 0, 0);
return(false);
}
else
{
float r1 = Vector3.Dot(normalPared, calculo1) / Vector3.Dot(normalPared, calculo2);
if (r1 >= 0 && r1 <= 1)
{
salida = Origen + r1 * calculo2;
return(true);
}
else
{
salida = new Vector3(0, 0, 0);
return(false);
}
}
}
/// <summary>
/// Crear a partir de un mesh
/// </summary>
public static TgcTriangleArray fromMesh(TgcMesh mesh)
{
TgcTriangleArray triangleArray = new TgcTriangleArray();
Vector3[] vertices = mesh.getVertexPositions();
int triCount = vertices.Length / 3;
List <TgcTriangle> triangles = new List <TgcTriangle>(triCount);
for (int i = 0; i < triCount; i++)
{
Vector3 v1 = vertices[i * 3];
Vector3 v2 = vertices[i * 3 + 1];
Vector3 v3 = vertices[i * 3 + 2];
TgcTriangle t = new TgcTriangle();
t.A = v1;
t.B = v2;
t.C = v3;
t.Color = Color.Red;
t.updateValues();
triangles.Add(t);
}
triangleArray.triangles.AddRange(triangles);
return(triangleArray);
}
/// <summary>
/// Se crea uncuerpo rigido a partir de un TgcMesh, pero no tiene masa por lo que va a ser estatico.
/// </summary>
/// <param name="mesh">TgcMesh</param>
/// <returns>Cuerpo rigido de un Mesh</returns>
public RigidBody CreateRigidBodyFromTgcMesh(TgcMesh mesh)
{
var vertexCoords = mesh.getVertexPositions();
TriangleMesh triangleMesh = new TriangleMesh();
for (int i = 0; i < vertexCoords.Length; i = i + 3)
{
triangleMesh.AddTriangle(vertexCoords[i].ToBulletVector3(), vertexCoords[i + 1].ToBulletVector3(), vertexCoords[i + 2].ToBulletVector3());
}
var transformationMatrix = TGCMatrix.RotationYawPitchRoll(0, 0, 0).ToBsMatrix;
DefaultMotionState motionState = new DefaultMotionState(transformationMatrix);
var bulletShape = new BvhTriangleMeshShape(triangleMesh, false);
var boxLocalInertia = bulletShape.CalculateLocalInertia(0);
var bodyInfo = new RigidBodyConstructionInfo(0, motionState, bulletShape, boxLocalInertia);
var rigidBody = new RigidBody(bodyInfo);
rigidBody.Friction = 0.4f;
rigidBody.RollingFriction = 1;
rigidBody.Restitution = 1f;
return(rigidBody);
}
/// <summary>
/// Crear a partir de un mesh
/// </summary>
public static TgcTriangleArray fromMesh(TgcMesh mesh, TgcD3dInput input)
{
var triangleArray = new TgcTriangleArray(input);
var vertices = mesh.getVertexPositions();
var triCount = vertices.Length / 3;
var triangles = new List <TgcTriangle>(triCount);
for (var i = 0; i < triCount; i++)
{
var v1 = vertices[i * 3];
var v2 = vertices[i * 3 + 1];
var v3 = vertices[i * 3 + 2];
var t = new TgcTriangle();
t.A = v1;
t.B = v2;
t.C = v3;
t.Color = Color.Red;
t.updateValues();
triangles.Add(t);
}
triangleArray.Triangles.AddRange(triangles);
return(triangleArray);
}
/// <summary>
/// Crea un BoundingSphere a partir de los vertices de un Mesh, utilizando el algoritmo de Ritter
/// </summary>
/// <param name="mesh">Mesh a partir del cual crear el BoundingSphere</param>
/// <returns>BoundingSphere creado</returns>
public static TgcBoundingSphere computeFromMesh(TgcMesh mesh)
{
Vector3[] vertices = mesh.getVertexPositions();
SphereStruct s = TgcBoundingSphere.computeFromPoints(vertices);
return(s.toClass());
}
private BvhTriangleMeshShape BuildTriangleMeshShape(TgcMesh mesh)
{
var vertexCoords = mesh.getVertexPositions();
TriangleMesh triangleMesh = new TriangleMesh();
for (int i = 0; i < vertexCoords.Length; i = i + 3)
{
triangleMesh.AddTriangle(vertexCoords[i].ToBulletVector3(), vertexCoords[i + 1].ToBulletVector3(), vertexCoords[i + 2].ToBulletVector3());
}
return(new BvhTriangleMeshShape(triangleMesh, false));
}
protected void CreateMesh(string rutaAMesh, TGCVector3 posicionInicial)
{
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(rutaAMesh);
this.mesh = scene.Meshes[0];
this.mesh.AutoTransform = false;
this.matrixs.SetScalation(TGCMatrix.Scaling(escaladoInicial));
this.matrixs.Translate(TGCMatrix.Translation(posicionInicial));
this.trasladoInicial = this.matrixs.GetTranslation();
this.mesh.BoundingBox.transform(this.matrixs.GetTransformation());
this.obb = new BoundingOrientedBox(this.mesh.BoundingBox);
this.mesh.Effect = TgcShaders.loadEffect(GlobalConcepts.GetInstance().GetShadersDir() + "EfectosVehiculo.fx");
mesh.Technique = "Iluminate";
this.pointsOfCollision = new PointsOfCollision(mesh.getVertexPositions());
this.pointsOfCollision.medium = (mesh.BoundingBox.PMax + mesh.BoundingBox.PMin) * 0.5f;
}
private CollisionObject CreateCollisionFromTgcMesh(TgcMesh mesh)
{
var vertexCoords = mesh.getVertexPositions();
TriangleMesh triangleMesh = new TriangleMesh();
for (int i = 0; i < vertexCoords.Length; i = i + 3)
{
triangleMesh.AddTriangle(vertexCoords[i].ToBulletVector3(), vertexCoords[i + 1].ToBulletVector3(), vertexCoords[i + 2].ToBulletVector3());
}
var transformationMatrix = TGCMatrix.RotationYawPitchRoll(0, 0, 0).ToBsMatrix;
var bulletShape = new BvhTriangleMeshShape(triangleMesh, false);
CollisionObject collisionObject = new CollisionObject();
collisionObject.CollisionShape = bulletShape;
return(collisionObject);
}
private static RigidBody CreateRigidBodyFromTgcMesh(TgcMesh mesh, TGCVector3 position, float mass)
{
var vertexCoords = mesh.getVertexPositions();
TriangleMesh triangleMesh = new TriangleMesh();
for (int i = 0; i < vertexCoords.Length; i = i + 3)
{
triangleMesh.AddTriangle(vertexCoords[i].ToBsVector, vertexCoords[i + 1].ToBsVector, vertexCoords[i + 2].ToBsVector);
}
var transformationMatrix = TGCMatrix.RotationYawPitchRoll(0, 0, 0).ToBsMatrix;
transformationMatrix.Origin = position.ToBsVector;
DefaultMotionState motionState = new DefaultMotionState(transformationMatrix);
var bulletShape = new ConvexTriangleMeshShape(triangleMesh, true);
var localInertia = bulletShape.CalculateLocalInertia(mass);
var bodyInfo = new RigidBodyConstructionInfo(mass, motionState, bulletShape, localInertia);
var rigidBody = new RigidBody(bodyInfo);
return(rigidBody);
}
/// <summary>
/// Crear Collider a partir de TgcMesh.
/// Los triangulos se calculan CounterClock-Wise.
/// Crea el BoundingSphere del Collider.
/// </summary>
/// <param name="mesh">TgcMesh</param>
/// <returns>Collider creado</returns>
public static TriangleMeshCollider fromMesh(TgcMesh mesh)
{
var collider = new TriangleMeshCollider();
//Cargar triangulos
var vertices = mesh.getVertexPositions();
var triangleCount = vertices.Length / 3;
collider.Triangles = new Triangle[triangleCount];
for (var i = 0; i < triangleCount; i++)
{
//Invertir orden de vertices para que la normal quede CounterClock-Wise
collider.Triangles[i] = new Triangle(vertices[i * 3 + 2],
vertices[i * 3 + 1],
vertices[i * 3]
);
}
//Crear BoundingSphere
collider.BoundingSphere = TgcBoundingSphere.computeFromMesh(mesh);
return(collider);
}
public Boolean interseccionRayoPlano(Vector3 Origen, Vector3 Destino, TgcMesh mesh)
{
Vector3 normalPared = calculoNormalPared(mesh);
Vector3 puntoPared = mesh.getVertexPositions()[0];
Vector3 calculo1 = puntoPared - Origen;
Vector3 calculo2 = Destino;
if (Vector3.Dot(normalPared, calculo2) == 0)
{
return(false);
}
else
{
float r1 = Vector3.Dot(normalPared, calculo1) / Vector3.Dot(normalPared, calculo2);
if (r1 >= 0)
{
return(true);
}
else
{
return(false);
}
}
}
public override void Init()
{
//Cargar un mesh
var loader = new TgcSceneLoader();
var scene =
loader.loadSceneFromFile(MediaDir +
"MeshCreator\\Meshes\\Cimientos\\PilarEgipcio\\PilarEgipcio-TgcScene.xml");
mesh = scene.Meshes[0];
//Obtener los vértices del mesh (esta operacion es lenta, copia de la GPU a la CPU, no hacer a cada rato)
var vertices = mesh.getVertexPositions();
//Iterar sobre todos los vertices y construir triangulos, normales y planos
var triCount = vertices.Length / 3;
triangles = new List <TgcTriangle>(triCount);
normals = new List <TgcArrow>();
planes = new List <TgcQuad>();
for (var i = 0; i < triCount; i++)
{
//Obtenemos los 3 vertices del triangulo, es importante saber como esta estructurado nuestro mesh.
var a = vertices[i * 3];
var b = vertices[i * 3 + 1];
var c = vertices[i * 3 + 2];
//Obtener normal del triangulo. El orden influye en si obtenemos el vector normal hacia adentro o hacia afuera del mesh
var normal = Vector3.Cross(c - a, b - a);
normal.Normalize();
//Crear plano que contiene el triangulo a partir un vertice y la normal
var plane = Plane.FromPointNormal(a, normal);
//Calcular el centro del triangulo. Hay muchos tipos de centros para un triangulo (http://www.mathopenref.com/trianglecenters.html)
//Aca calculamos el mas simple
var center = Vector3.Scale(a + b + c, 1 / 3f);
///////////// Creacion de elementos para poder dibujar a pantalla (propios de este ejemplo) ///////////////
//Crear un quad (pequeno plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
var quad = new TgcQuad();
quad.Center = center;
quad.Normal = normal;
quad.Color = adaptColorRandom(Color.DarkGreen);
quad.Size = new Vector2(10, 10);
quad.updateValues();
planes.Add(quad);
//Creamos una flecha con la clase TgcArrow para poder dibujar la normal (la normal la estiramos un poco para que se pueda ver)
normals.Add(TgcArrow.fromDirection(center, Vector3.Scale(normal, 10f)));
//Creamos la clase TgcTriangle que es un helper para dibujar triangulos sueltos
var t = new TgcTriangle();
t.A = a;
t.B = b;
t.C = c;
t.Color = adaptColorRandom(Color.Red);
t.updateValues();
triangles.Add(t);
}
//Modifiers
Modifiers.addBoolean("mesh", "mesh", true);
Modifiers.addBoolean("triangles", "triangles", true);
Modifiers.addBoolean("normals", "normals", true);
Modifiers.addBoolean("planes", "planes", false);
//Camera
Camara = new TgcRotationalCamera(mesh.BoundingBox.calculateBoxCenter(),
mesh.BoundingBox.calculateBoxRadius() * 2, Input);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar un mesh
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Cimientos\\PilarEgipcio\\PilarEgipcio-TgcScene.xml");
mesh = scene.Meshes[0];
//Obtener los vértices del mesh (esta operacion es lenta, copia de la GPU a la CPU, no hacer a cada rato)
Vector3[] vertices = mesh.getVertexPositions();
//Iterar sobre todos los vertices y construir triangulos, normales y planos
int triCount = vertices.Length / 3;
triangles = new List <TgcTriangle>(triCount);
normals = new List <TgcArrow>();
planes = new List <TgcQuad>();
for (int i = 0; i < triCount; i++)
{
//Obtenemos los 3 vertices del triangulo
Vector3 a = vertices[i * 3];
Vector3 b = vertices[i * 3 + 1];
Vector3 c = vertices[i * 3 + 2];
//Obtener normal del triangulo. El orden influye en si obtenemos el vector normal hacia adentro o hacia afuera del mesh
Vector3 normal = Vector3.Cross(c - a, b - a);
normal.Normalize();
//Crear plano que contiene el triangulo a partir un vertice y la normal
Plane plane = Plane.FromPointNormal(a, normal);
//Calcular el centro del triangulo. Hay muchos tipos de centros para un triangulo (http://www.mathopenref.com/trianglecenters.html)
//Aca calculamos el mas simple
Vector3 center = Vector3.Scale(a + b + c, 1 / 3f);
///////////// Creacion de elementos para poder dibujar a pantalla (propios de este ejemplo) ///////////////
//Crear un quad (pequeño plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
TgcQuad quad = new TgcQuad();
quad.Center = center;
quad.Normal = normal;
quad.Color = adaptColorRandom(Color.DarkGreen);
quad.Size = new Vector2(10, 10);
quad.updateValues();
planes.Add(quad);
//Creamos una flecha con la clase TgcArrow para poder dibujar la normal (la normal la estiramos un poco para que se pueda ver)
normals.Add(TgcArrow.fromDirection(center, Vector3.Scale(normal, 10f)));
//Creamos la clase TgcTriangle que es un helper para dibujar triangulos sueltos
TgcTriangle t = new TgcTriangle();
t.A = a;
t.B = b;
t.C = c;
t.Color = adaptColorRandom(Color.Red);
t.updateValues();
triangles.Add(t);
}
//Modifiers
GuiController.Instance.Modifiers.addBoolean("mesh", "mesh", true);
GuiController.Instance.Modifiers.addBoolean("triangles", "triangles", true);
GuiController.Instance.Modifiers.addBoolean("normals", "normals", true);
GuiController.Instance.Modifiers.addBoolean("planes", "planes", false);
//Camera
GuiController.Instance.RotCamera.Enable = true;
GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox);
}
public TGCVector3[] getVertexPositions() => rampaMesh.getVertexPositions();