private void Awake()
{
mesh = new Mesh();
triangleMesh = new TriangleMesh();
lodMeshFilter = GetComponent<MeshFilter>();
lodMeshRenderer = GetComponent<MeshRenderer>();
lodMeshCollider = GetComponent<MeshCollider>();
lodMeshRenderer.sharedMaterial = Material;
lodMeshFilter.mesh = mesh;
}
public void AddTriangleWithoutMergingAndWithDestroyedLists()
{
var mesh = new TriangleMesh();
// Destroy lists.
mesh.Vertices = null;
mesh.Indices = null;
Assert.AreEqual(0, mesh.NumberOfTriangles);
mesh.Add(new Triangle(new Vector3F(1, 1, 1), new Vector3F(1, 1, 1), new Vector3F(1, 1, 1.000001f)), false, 0.001f, false);
Assert.AreEqual(3, mesh.Vertices.Count);
}
public void AddMesh()
{
TriangleMesh mesh = new TriangleMesh();
mesh.Add(new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 2)), true);
mesh.Add(new Triangle(new Vector3F(0, 1, 0), new Vector3F(1, 2, 1), new Vector3F(1, 1, 1)), true);
var mesh2 = new TriangleMesh();
mesh2.Add(new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 1)), true);
mesh2.Add(mesh, true);
Assert.AreEqual(3, mesh2.NumberOfTriangles);
Assert.AreEqual(new Triangle(new Vector3F(0, 1, 0), new Vector3F(1, 2, 1), new Vector3F(1, 1, 1)), mesh2.GetTriangle(2));
}
public void Clone()
{
var mesh = new TriangleMesh();
mesh.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), true);
mesh.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), true);
mesh.Tag = new SphereShape(3);
var clone = mesh.Clone();
Assert.AreEqual(mesh.NumberOfTriangles, clone.NumberOfTriangles);
Assert.AreEqual(mesh.GetTriangle(0), clone.GetTriangle(0));
Assert.AreEqual(mesh.GetTriangle(1), clone.GetTriangle(1));
Assert.AreSame(mesh.Tag, clone.Tag);
mesh.Tag = new MemoryStream();
clone = mesh.Clone();
Assert.AreSame(mesh.Tag, clone.Tag);
}
/// <summary>
/// Allows us to specify a lowPoly collision skin model
/// </summary>
/// <param name="id"></param>
/// <param name="actorType"></param>
/// <param name="transform"></param>
/// <param name="effectParameters"></param>
/// <param name="model"></param>
/// <param name="lowPolygonModel"></param>
/// <param name="materialProperties"></param>
public TriangleMeshObject(string id, ActorType actorType, StatusType statusType, Transform3D transform,
EffectParameters effectParameters, Model model,
Model lowPolygonModel, MaterialProperties materialProperties)
: base(id, actorType, statusType, transform, effectParameters, model)
{
//get the primitive mesh which forms the skin - use low poly if it has been provided in the constructor
TriangleMesh triangleMesh = null;
if (lowPolygonModel != null)
{
triangleMesh = GetTriangleMesh(lowPolygonModel, this.Transform3D);
}
else
{
triangleMesh = GetTriangleMesh(model, this.Transform3D);
}
//add the primitive mesh to the collision skin
this.Body.CollisionSkin.AddPrimitive(triangleMesh, materialProperties);
}
public static IEnumerable <IShape> CreatePlane(Point min, Point max)
{
var tr = Transform.Identity;
return(TriangleMesh.CreateTriangleMesh(
tr,
Transform.Invert(tr),
false,
2,
new[] { 0, 1, 2, 0, 2, 3 },
4,
new[]
{
min,
new Point(min.X, max.Y, max.Z),
max,
new Point(max.X, min.Y, min.Z),
},
null,
null, null, null, null, null));
}
private static TriangleMesh CreateTriangleMesh(List <int> indices, List <Vector3> vertices, Vector3 localScaling)
{
var triangleMesh = new TriangleMesh();
int triangleCount = indices.Count / 3;
for (int i = 0; i < triangleCount; i++)
{
int index0 = indices[i * 3];
int index1 = indices[i * 3 + 1];
int index2 = indices[i * 3 + 2];
Vector3 vertex0 = vertices[index0] * localScaling;
Vector3 vertex1 = vertices[index1] * localScaling;
Vector3 vertex2 = vertices[index2] * localScaling;
triangleMesh.AddTriangleRef(ref vertex0, ref vertex1, ref vertex2);
}
return(triangleMesh);
}
public void ShadingNormals_ShouldBeSet()
{
var vertices = new Vector3[] {
new Vector3(-1, 0, -1),
new Vector3(1, 0, -1),
new Vector3(1, 0, 1),
new Vector3(-1, 0, -1),
new Vector3(1, 0, -1),
new Vector3(-1, 0, 1)
};
var indices = new int[] {
0, 1, 2,
3, 4, 5
};
var normals = new Vector3[] {
new Vector3(1, 0, 0),
new Vector3(1, 0, 0),
new Vector3(1, 0, 0),
new Vector3(1, 0, -1),
new Vector3(1, 0, -1),
new Vector3(1, 0, -1),
};
TriangleMesh mesh = new TriangleMesh(vertices, indices, shadingNormals: normals);
var n1 = mesh.ComputeShadingNormal(0, new Vector2(0.5f, 0.5f));
var n2 = mesh.ComputeShadingNormal(1, new Vector2(0.5f, 0.5f));
Assert.Equal(1, n1.X, 3);
Assert.Equal(0, n1.Y, 3);
Assert.Equal(0, n1.Z, 3);
Assert.Equal(1.0f / MathF.Sqrt(2), n2.X, 3);
Assert.Equal(0, n2.Y, 3);
Assert.Equal(-1.0f / MathF.Sqrt(2), n2.Z, 3);
}
/// <summary>
/// Calculates the Vertex normals as an average of the normals of the normals of the incident Edges,
/// that are calculated as the average of the normals of the incident Triangles weighted by the inverse of their area.
/// </summary>
/// <param name="mesh">Reference to the TriangleMesh to calculate the vertex normals for.</param>
public void GetVertexNormals(ref TriangleMesh mesh)
{
for (int i = 0; i < mesh.Vertices.Count; i++)
{
Vertex vertex = mesh.Vertices[i];
vertex.Normal = new Vector(0, 0, 0);
for (int j = 0; j < vertex.Triangles.Count; j++)
{
Triangle triangle = mesh[vertex.Triangles[j]];
int[] neighbors = triangle.GetNeighborsOf(i);
double weight = 1 /
(Vector.Distance(mesh.Vertices[i], mesh.Vertices[neighbors[0]])
* Triangle.GetAreaOf(vertex, triangle.Centroid, mesh.Vertices[neighbors[0]]));
weight += 1 /
(Vector.Distance(mesh.Vertices[i], mesh.Vertices[neighbors[1]])
* Triangle.GetAreaOf(vertex, triangle.Centroid, mesh.Vertices[neighbors[1]]));
vertex.Normal += weight * triangle.Normal;
}
vertex.Normal.Normalize();
}
}
/// <summary>
/// Called when a mesh should be generated for the shape.
/// </summary>
/// <param name="absoluteDistanceThreshold">The absolute distance threshold.</param>
/// <param name="iterationLimit">The iteration limit.</param>
/// <returns>The triangle mesh for this shape.</returns>
/// <remarks>
/// A deep copy of the <see cref="Mesh"/> is returned.
/// </remarks>
protected override TriangleMesh OnGetMesh(float absoluteDistanceThreshold, int iterationLimit)
{
var triangleMesh = Mesh as TriangleMesh;
if (triangleMesh != null)
{
return(triangleMesh.Clone());
}
// Return a copy of the mesh.
TriangleMesh mesh = new TriangleMesh();
int numberOfTriangles = _mesh.NumberOfTriangles;
for (int i = 0; i < numberOfTriangles; i++)
{
Triangle triangle = _mesh.GetTriangle(i);
mesh.Add(triangle, false);
}
mesh.WeldVertices();
return(mesh);
}
public TriangleMeshObject(Game game, Model model, Matrix orientation, Vector3 position)
: base(game, model)
{
body = new Body();
collision = new CollisionSkin(null);
triangleMesh = new TriangleMesh();
List <Vector3> vertexList = new List <Vector3>();
List <TriangleVertexIndices> indexList = new List <TriangleVertexIndices>();
ExtractData(vertexList, indexList, model);
triangleMesh.CreateMesh(vertexList, indexList, 4, 1.0f);
collision.AddPrimitive(triangleMesh, new MaterialProperties(0.8f, 0.7f, 0.6f));
PhysicsSystem.CurrentPhysicsSystem.CollisionSystem.AddCollisionSkin(collision);
// Transform
collision.ApplyLocalTransform(new JigLibX.Math.Transform(position, orientation));
// we also need to move this dummy, so the object is *rendered* at the correct positiob
body.MoveTo(position, orientation);
}
/// <summary>
/// Performs parameterization with the chosen method on the given mesh
/// The mesh is assumed to be non-closed with proper boundary
/// </summary>
/// <param name="meshIn">input mesh, after solving its texture coordinates in vertex traits will be adjusted</param>
/// <param name="meshOut">an flattened output mesh with only X,Y coordinates set, Z is set to 0</param>
public void PerformParameterization(TriangleMesh meshin, out TriangleMesh meshout)
{
switch (this.SelectedMethod)
{
default:
case Method.Barycentric:
BarycentricMapping(meshin, out meshout);
break;
case Method.LSCM:
LSCM(meshin, out meshout);
break;
case Method.DCP:
DCP(meshin, out meshout);
break;
case Method.LinearABF:
LinearABF(meshin, out meshout);
break;
}
}
/// </summary>
public static TripletMatrix CreateUniformLaplacian(TriangleMesh mesh, double lambda = 0.0, double eye = 0.0, bool normalized = false)
{
int n = mesh.Vertices.Count;
int nz = mesh.Vertices.Aggregate(0, (c, x) => x.VertexCount());
var L = new TripletMatrix(n, n, nz, true);
/// build adjacence A and uniform L matrix
for (int i = 0; i < n; i++)
{
var v = mesh.Vertices[i];
var wsum = (double)v.VertexCount();
var wij = 1.0;
foreach (var vj in v.Vertices)
{
int j = vj.Index;
if (normalized)
{
L[i, j] = lambda * (wij / wsum);
}
else
{
L[i, j] = lambda * (wij);
}
}
if (normalized)
{
L[i, i] = eye - lambda * 1;
}
else
{
L[i, i] = eye - lambda * wsum;
}
}
return(L);
}
public void WriteRawFormatToFile(BinaryWriter writer, TriangleMesh mesh)
{
writer.Write(mesh.NumVertices);
foreach (var Entry in mesh.Vertices)
{
Vector3Utils.WriteToFile(Entry, writer);
}
writer.Write(mesh.NumTriangles * 3); // Write Number of Indices, not triangles.
foreach (var Entry in mesh.Triangles)
{
writer.Write(Entry.v0);
writer.Write(Entry.v1);
writer.Write(Entry.v2);
}
writer.Write(mesh.MaterialIndices.Count);
foreach (var Entry in mesh.MaterialIndices)
{
writer.Write(Entry);
}
}
///<summary>
/// Constructs a new mobile mesh shape.
///</summary>
///<param name="vertices">Vertices of the mesh.</param>
///<param name="indices">Indices of the mesh.</param>
///<param name="localTransform">Local transform to apply to the shape.</param>
///<param name="solidity">Solidity state of the shape.</param>
/// <param name="center">Center of the shape.</param>
public MobileMeshShape(Vector3[] vertices, int[] indices, AffineTransform localTransform,
MobileMeshSolidity solidity, out Vector3 center)
{
this.solidity = solidity;
TransformableMeshData data = new TransformableMeshData(vertices, indices, localTransform);
ShapeDistributionInformation shapeDistributionInformation = ComputeVolumeDistribution(data);
data.worldTransform.Translation -= shapeDistributionInformation.Center;
center = shapeDistributionInformation.Center;
TriangleMesh = new TriangleMesh(data);
UpdateEntityShapeVolume(new EntityShapeVolumeDescription
{
Volume = shapeDistributionInformation.Volume,
VolumeDistribution = shapeDistributionInformation.VolumeDistribution
});
ComputeSolidSidedness();
UpdateSurfaceVertices();
}
// Token: 0x06001E27 RID: 7719 RVA: 0x001BDEC8 File Offset: 0x001BC0C8
public override void InitiateSprites(RoomCamera.SpriteLeaser sLeaser, RoomCamera rCam)
{
sLeaser.sprites = new FSprite[this.TotalSprites];
sLeaser.sprites[this.BodySprite] = new FSprite("pixel", true);
sLeaser.sprites[this.BodySprite].scale = Mathf.Lerp(0.4f, 0.7f, this.fish.iVars.fatness);
sLeaser.sprites[this.HeadSprite] = new FSprite("pixel", true);
sLeaser.sprites[this.HeadSprite].scale = 0.6f;
sLeaser.sprites[this.JawSprite] = new FSprite("pixel", true);
sLeaser.sprites[this.JawSprite].scale = 0.7f;
sLeaser.sprites[NeckSprite] = TriangleMesh.MakeLongMesh(fish.neck.tChunks.Length, false, false);
(sLeaser.sprites[NeckSprite] as TriangleMesh).alpha = 1f;
for (int i = 0; i < this.danglers.Length; i++)
{
this.danglers[i].InitSprite(sLeaser, HeadDanglerSprite(i));
sLeaser.sprites[HeadDanglerSprite(i)].shader = rCam.room.game.rainWorld.Shaders["TentaclePlant"];
sLeaser.sprites[HeadDanglerSprite(i)].alpha = Mathf.InverseLerp(2f, 12f, (float)this.danglers[i].segments.Length) * 0.9f + 0.1f * this.danglerProps[i, 2];
}
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < this.fish.iVars.whiskers; j++)
{
sLeaser.sprites[this.WhiskerSprite(i, j)] = TriangleMesh.MakeLongMesh(4, true, false);
}
}
sLeaser.sprites[this.TentacleSprite()] = TriangleMesh.MakeLongMesh(this.tail.Length, true, false);
sLeaser.sprites[this.WingSprite(0)] = TriangleMesh.MakeLongMesh(10, true, false);
sLeaser.sprites[this.WingSprite(1)] = TriangleMesh.MakeLongMesh(10, true, false);
for (int k = 0; k < 2; k++)
{
sLeaser.sprites[this.FlipperSprite(k)] = new FSprite("JetFishFlipper" + this.fish.iVars.flipper, true);
this.flipperGraphWidth = Futile.atlasManager.GetElementWithName("JetFishFlipper" + this.fish.iVars.flipper).sourcePixelSize.x;
sLeaser.sprites[this.FlipperSprite(k)].alpha = 0f;
sLeaser.sprites[this.FlipperSprite(k)].anchorX = 0f;
sLeaser.sprites[this.FlipperSprite(k)].anchorY = SeaDrakeGraphics.flipperGraphConPointHeights[this.fish.iVars.flipper] / Futile.atlasManager.GetElementWithName("JetFishFlipper" + this.fish.iVars.flipper).sourcePixelSize.y;
}
this.AddToContainer(sLeaser, rCam, null);
base.InitiateSprites(sLeaser, rCam);
}
/// <summary>
/// Called when a mesh should be generated for the shape.
/// </summary>
/// <param name="absoluteDistanceThreshold">The absolute distance threshold.</param>
/// <param name="iterationLimit">The iteration limit.</param>
/// <returns>The triangle mesh for this shape.</returns>
/// <remarks>
/// This method creates a triangle mesh that represents a square lying in the plane. The square
/// has an edge length of <see cref="MeshSize"/>.
/// </remarks>
protected override TriangleMesh OnGetMesh(float absoluteDistanceThreshold, int iterationLimit)
{
Vector3 center = Normal * DistanceFromOrigin;
Vector3 orthoNormal1 = Normal.Orthonormal1;
Vector3 orthoNormal2 = Normal.Orthonormal2;
// Plane
// Make 4 triangles around the center.
TriangleMesh mesh = new TriangleMesh();
mesh.Add(new Triangle
{
Vertex0 = center,
Vertex1 = center + orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2,
Vertex2 = center + orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2,
}, true);
mesh.Add(new Triangle
{
Vertex0 = center,
Vertex1 = center + orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2,
Vertex2 = center - orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2,
}, true);
mesh.Add(new Triangle
{
Vertex0 = center,
Vertex1 = center - orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2,
Vertex2 = center - orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2,
}, true);
mesh.Add(new Triangle
{
Vertex0 = center,
Vertex1 = center - orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2,
Vertex2 = center + orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2,
}, true);
return(mesh);
}
/// <summary>
/// Calculates the Vertex normals as an average of the normals of the incident Triangles,
/// weighted by the angle between the neighboring Vertices.
/// As the Triangle normal can be calculated from the neighboring Vertices,
/// the actual Triangle normals and the angles are not needed.
/// (More exact, since the calculation of the angle requires calculating an arcus cosine.)
/// The cross product of the neighbors is calculated and divided by the product of their length instead.
/// </summary>
/// <param name="mesh">Reference to the TriangleMesh to calculate the vertex normals for.</param>
public void GetVertexNormals(ref TriangleMesh mesh)
{
Vector pro1, pro2;
double factor;
int[] neighbors;
for (int i = 0; i < mesh.Vertices.Count; i++)
{
Vertex vertex = mesh.Vertices[i];
vertex.Normal = new Vector(0, 0, 0);
for (int j = 0; j < vertex.Triangles.Count; j++)
{
neighbors = mesh[vertex.Triangles[j]].GetNeighborsOf(i);
pro1 = mesh.Vertices[neighbors[0]] - vertex;
pro2 = mesh.Vertices[neighbors[1]] - vertex;
factor = pro1.SquaredLength() * pro2.SquaredLength();
vertex.Normal += (pro1 % pro2) / factor;
}
vertex.Normal.Normalize();
}
}
/// </summary>
public static TripletMatrix CreateBoundedUniformLaplacian(TriangleMesh mesh, double lambda = 0.0, double eye = 0.0, bool normalized = false)
{
var vertexCount = mesh.Vertices.Count;
int neighborCount = mesh.Vertices.Aggregate(0, (c, x) => x.VertexCount());
var L = new TripletMatrix(vertexCount, vertexCount, neighborCount, true);
foreach (var currentVertex in mesh.Vertices)
{
if (currentVertex.OnBoundary)
{
L.Entry(currentVertex.Index, currentVertex.Index, 1d);
continue;
}
// Diagonal entry v(i,i) = eye*1 + λ*L(i,i)
var diagonalVal = eye + GetNormalized(currentVertex.Vertices.Count(), currentVertex.VertexCount(), normalized) * lambda;
L.Entry(currentVertex.Index, currentVertex.Index, diagonalVal);
currentVertex.Vertices.Apply(nb =>
L.Entry(currentVertex.Index, nb.Index, GetNormalized(-1, currentVertex.VertexCount(), normalized) * lambda));
}
return(L);
}
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);
}
public override void InitiateSprites(RoomCamera.SpriteLeaser sLeaser, RoomCamera rCam)
{
sLeaser.sprites = new FSprite[1];
var tris = new TriangleMesh.Triangle[]
{
new TriangleMesh.Triangle(0, 1, 2),
new TriangleMesh.Triangle(2, 1, 3)
};
var mesh = new TriangleMesh(spriteName, tris, false);
mesh.MoveVertice(0, new Vector2(0f, 0f));
mesh.MoveVertice(1, new Vector2(0f, rCam.sSize.y));
mesh.MoveVertice(2, new Vector2(rCam.sSize.x, 0f));
mesh.MoveVertice(3, new Vector2(rCam.sSize.x, rCam.sSize.y));
mesh.UVvertices[0] = new Vector2(0f, 0f);
mesh.UVvertices[1] = new Vector2(0f, 2f);
mesh.UVvertices[2] = new Vector2(2f, 0f);
mesh.UVvertices[3] = new Vector2(2f, 2f);
sLeaser.sprites[0] = mesh;
sLeaser.sprites[0].alpha = 0f;
this.AddToContainer(sLeaser, rCam, rCam.ReturnFContainer("HUD"));
}
// Creates a TriangleMeshShape for the water surface. The surface is curved and
// inclined.
private static Shape GetSpiralShape()
{
var triangleMesh = new TriangleMesh();
const int numberOfQuads = 12;
const float innerRadius = 1;
const float outerRadius = 2;
float angle = 0;
float y = 0;
for (int i = 0; i <= numberOfQuads; i++, angle += 0.4f, y -= 0.02f)
{
float cos = (float)Math.Cos(angle);
float sin = (float)Math.Sin(angle);
triangleMesh.Vertices.Add(new Vector3(outerRadius * cos, y, outerRadius * sin));
triangleMesh.Vertices.Add(new Vector3(innerRadius * cos, y, innerRadius * sin));
if (i == 5)
{
y -= 0.2f;
}
}
// Add 2 triangles per quad.
for (int i = 0; i < numberOfQuads; i++)
{
triangleMesh.Indices.Add(i * 2 + 0);
triangleMesh.Indices.Add(i * 2 + 1);
triangleMesh.Indices.Add(i * 2 + 2);
triangleMesh.Indices.Add(i * 2 + 1);
triangleMesh.Indices.Add(i * 2 + 3);
triangleMesh.Indices.Add(i * 2 + 2);
}
return(new TriangleMeshShape(triangleMesh));
}
/// <summary>
///
/// </summary>
/// <param name="mesh"></param>
/// <returns></returns>
public bool Smooth(TriangleMesh mesh)
{
switch (this.SelectedMethod)
{
default:
case Method.Explicit_Euler:
this.ExplicitEulerSmoothing(mesh, this.Iterations);
break;
case Method.Implicit_Euler:
this.ImplicitEulerSmoothing(mesh);
break;
case Method.LS_Optimization:
this.GlobalLeastSquaresSmoothing(mesh);
break;
case Method.TriangleQuality:
this.TriangleQualityOptimization(mesh);
break;
}
return(true);
}
public static RigidBody CreateRigidBodyFromTgcMesh(TgcMesh mesh, TGCVector3 position)
{
var meshAxisRadius = mesh.BoundingBox.calculateAxisRadius().ToBsVector;
var boxShape = new BoxShape(meshAxisRadius);
var transformationMatrix = TGCMatrix.RotationYawPitchRoll(0, 0, 0).ToBsMatrix;
transformationMatrix.Origin = position.ToBsVector;
DefaultMotionState motionState = new DefaultMotionState(transformationMatrix);
var boxLocalInertia = boxShape.CalculateLocalInertia(0);
var qwe = new TriangleMesh();
var asd = new BvhTriangleMeshShape(qwe, false);
var bodyInfo = new RigidBodyConstructionInfo(0, motionState, asd, boxLocalInertia);
var rigidBody = new RigidBody(bodyInfo);
rigidBody.Friction = 0.4f;
rigidBody.RollingFriction = 1;
// ballBody.SetDamping(0.1f, 0.9f);
rigidBody.Restitution = 1f;
return(rigidBody);
}
public void FromTriangleMesh2()
{
var mesh = new TriangleMesh();
mesh.Vertices.Add(new Vector3F(0, 0, 0));
mesh.Vertices.Add(new Vector3F(1, 1, 1));
mesh.Vertices.Add(new Vector3F(2, 2, 2));
mesh.Vertices.Add(new Vector3F(3, 3, 3));
//mesh.Vertices.Add(new Vector3F(405, 322, 0));
mesh.Indices.Add(0);
mesh.Indices.Add(1);
mesh.Indices.Add(2);
mesh.Indices.Add(1);
mesh.Indices.Add(3);
mesh.Indices.Add(2);
var dcel = DcelMesh.FromTriangleMesh((ITriangleMesh)mesh);
Assert.AreEqual(4, dcel.Vertices.Count);
Assert.AreEqual(2, dcel.Faces.Count);
Assert.AreEqual(10, dcel.Edges.Count);
Assert.IsTrue(dcel.IsValid());
Assert.IsFalse(dcel.IsClosed());
Assert.IsTrue(dcel.IsTriangleMesh());
}
public void AddTriangleToleranceMustBeGreaterNull()
{
TriangleMesh mesh = new TriangleMesh();
mesh.Add(new Triangle(), true, 0, true);
}
public void AddTriangleShouldRemoveDegenerateTriangle2()
{
var mesh = new TriangleMesh();
mesh.Add(new Triangle(new Vector3F(1, 1, 1), new Vector3F(1, 1, 1), new Vector3F(1, 1, 1.000001f)), false, 0.001f, true);
Assert.AreEqual(0, mesh.NumberOfTriangles);
}
public void WeldVertices()
{
TriangleMesh mesh = new TriangleMesh();
Assert.AreEqual(0, mesh.WeldVertices());
mesh.Add(new Triangle(new Vector3F(1, 2, 3), new Vector3F(3, 4, 5), new Vector3F(1.00001f, 2.00001f, 3f)), false);
Assert.AreEqual(3, mesh.Vertices.Count);
Assert.Throws(typeof(ArgumentOutOfRangeException), () => mesh.WeldVertices(-0.1f));
Assert.AreEqual(1, mesh.WeldVertices(0.0001f));
Assert.AreEqual(2, mesh.Vertices.Count);
var w = Stopwatch.StartNew();
mesh = new SphereShape(0.5f).GetMesh(0.001f, 7);
w.Stop();
//Assert.AreEqual(0, w.Elapsed.TotalMilliseconds);
for (int i = 0; i < mesh.Vertices.Count; i++)
{
for (int j = i + 1; j < mesh.Vertices.Count; j++)
{
Assert.IsFalse(Vector3F.AreNumericallyEqual(mesh.Vertices[i], mesh.Vertices[j]));
}
}
// Second time does nothing.
Assert.AreEqual(0, mesh.WeldVertices());
}
public static Mesh Construct(TriangleMesh metaResource)
{
var mesh = new Mesh
{
MeshType = MeshType.Indexed,
VertexStreamLayout = Vertex.Position3Normal3Texcoord3.Instance
};
if (!metaResource.TwoSided)
{
mesh.NVertices = 3;
mesh.NFaces = 1;
}
else
{
mesh.NVertices = 6;
mesh.NFaces = 2;
}
Vector3 an = Vector3.Cross(metaResource.PositionB - metaResource.PositionA, metaResource.PositionC - metaResource.PositionA);
an.Normalize();
Vector3 bn = Vector3.Cross(metaResource.PositionC - metaResource.PositionB, metaResource.PositionA - metaResource.PositionB);
bn.Normalize();
Vector3 cn = Vector3.Cross(metaResource.PositionA - metaResource.PositionC, metaResource.PositionB - metaResource.PositionC);
cn.Normalize();
List<Vertex.Position3Normal3Texcoord3> verts = new List<Vertex.Position3Normal3Texcoord3>();
verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionA, an, Common.Math.ToVector3(metaResource.UVA)));
verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionB, bn, Common.Math.ToVector3(metaResource.UVB)));
verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionC, cn, Common.Math.ToVector3(metaResource.UVC)));
if (metaResource.TwoSided)
{
verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionA, -an, Common.Math.ToVector3(metaResource.UVA)));
verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionB, -bn, Common.Math.ToVector3(metaResource.UVB)));
verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionC, -cn, Common.Math.ToVector3(metaResource.UVC)));
}
mesh.VertexBuffer = new VertexBuffer<Vertex.Position3Normal3Texcoord3>(verts.ToArray());
List<int> indices = new List<int>();
indices.Add(0);
indices.Add(1);
indices.Add(2);
if (metaResource.TwoSided)
{
indices.Add(2 + 3);
indices.Add(1 + 3);
indices.Add(0 + 3);
}
mesh.IndexBuffer = new IndexBuffer(indices.ToArray());
return mesh;
}
public void Transform()
{
var mesh = new TriangleMesh();
mesh.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), true);
mesh.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), true);
var trans = RandomHelper.Random.NextMatrix44F(-1, 1);
mesh.Transform(trans);
Assert.AreEqual(trans.TransformPosition(new Vector3F(0, 1, 2)), mesh.Vertices[0]);
Assert.AreEqual(trans.TransformPosition(new Vector3F(-6, -7, -8)), mesh.Vertices[5]);
}
public void SerializationBinary()
{
var a = new TriangleMesh();
a.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), false);
a.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), false);
// Serialize object.
var stream = new MemoryStream();
var formatter = new BinaryFormatter();
formatter.Serialize(stream, a);
// Deserialize object.
stream.Position = 0;
var deserializer = new BinaryFormatter();
var b = (TriangleMesh)deserializer.Deserialize(stream);
Assert.AreEqual(a.NumberOfTriangles, b.NumberOfTriangles);
for (int i = 0; i < a.Vertices.Count; i++)
Assert.AreEqual(a.Vertices[i], b.Vertices[i]);
for (int i = 0; i < a.Indices.Count; i++)
Assert.AreEqual(a.Indices[i], b.Indices[i]);
}
public void GetTriangleException2()
{
TriangleMesh mesh = new TriangleMesh();
mesh.Add(new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 1)), false);
mesh.GetTriangle(1);
}
/// <summary>
/// Generic OBJ-loading scene definition routine.
/// </summary>
/// <param name="dir">Viewing direction of a camera.</param>
/// <param name="FoVy">Field of View in degrees.</param>
/// <param name="correction">Value less than 1.0 brings camera nearer.</param>
/// <param name="name">OBJ file-name.</param>
/// <param name="names">Substitute file-name[s].</param>
/// <returns>Number of triangles.</returns>
protected static long SceneObj( IRayScene sc, Vector3d dir, double FoVy, double correction, string name, string[] names, double[] surfaceColor )
{
Debug.Assert( sc != null );
Vector3 center = Vector3.Zero; // center of the mesh
dir.Normalize(); // normalized viewing vector of the camera
float diameter = 2.0f; // default scene diameter
int faces = 0;
// CSG scene:
CSGInnerNode root = new CSGInnerNode( SetOperation.Union );
// OBJ file to read:
if ( names.Length == 0 ||
names[ 0 ].Length == 0 )
names = new string[] { name };
string[] paths = Scenes.SmartFindFiles( names );
if ( paths[ 0 ] == null || paths[ 0 ].Length == 0 )
{
for ( int i = 0; i < names.Length; i++ )
if ( names[ i ].Length > 0 )
names[ i ] += ".gz";
paths = Scenes.SmartFindFiles( names );
}
if ( paths[ 0 ] == null || paths[ 0 ].Length == 0 )
root.InsertChild( new Sphere(), Matrix4d.Identity );
else
{
// B-rep scene construction:
WavefrontObj objReader = new WavefrontObj();
objReader.MirrorConversion = false;
SceneBrep brep = new SceneBrep();
faces = objReader.ReadBrep( paths[ 0 ], brep );
brep.BuildCornerTable();
diameter = brep.GetDiameter( out center );
TriangleMesh m = new TriangleMesh( brep );
root.InsertChild( m, Matrix4d.Identity );
}
root.SetAttribute( PropertyName.REFLECTANCE_MODEL, new PhongModel() );
root.SetAttribute( PropertyName.MATERIAL, new PhongMaterial( surfaceColor, 0.2, 0.5, 0.4, 32 ) );
root.SetAttribute( PropertyName.COLOR, surfaceColor );
sc.Intersectable = root;
// Background color:
sc.BackgroundColor = new double[] { 0.0, 0.05, 0.07 };
// Camera:
double dist = (0.5 * diameter * correction) / Math.Tan( MathHelper.DegreesToRadians( (float)(0.5 * FoVy) ) );
Vector3d cam = (Vector3d)center - dist * dir;
sc.Camera = new StaticCamera( cam, dir, FoVy );
// Light sources:
sc.Sources = new LinkedList<ILightSource>();
sc.Sources.Add( new AmbientLightSource( 0.8 ) );
Vector3d lightDir = Vector3d.TransformVector( dir, Matrix4d.CreateRotationY( -2.0 ) );
lightDir = Vector3d.TransformVector( lightDir, Matrix4d.CreateRotationZ( -0.8 ) );
sc.Sources.Add( new PointLightSource( (Vector3d)center + diameter * lightDir, 1.0 ) );
return faces;
}
private void Evaluate(TriangleMesh triangleMesh, Corner start, Corner mid, Corner end, bool startEnabled, bool midEnabled, bool endEnabled, Vector2 reference)
{
if (startEnabled && endEnabled && midEnabled)
{
triangleMesh.AddTriangle(new Triangle(
(Center.Position - reference).XYZ(Center.Height),
(mid.Position - reference).XYZ(mid.Height),
(start.Position - reference).XYZ(start.Height)));
triangleMesh.AddTriangle(new Triangle(
(end.Position - reference).XYZ(end.Height),
(mid.Position - reference).XYZ(mid.Height),
(Center.Position - reference).XYZ(Center.Height)));
}
else if (startEnabled && endEnabled)
{
triangleMesh.AddTriangle(new Triangle(
(start.Position - reference).XYZ(start.Height),
(Center.Position - reference).XYZ(Center.Height),
(end.Position - reference).XYZ(end.Height)));
}
else if (startEnabled && !endEnabled)
{
triangleMesh.AddTriangle(new Triangle(
(Center.Position - reference).XYZ(Center.Height),
(mid.Position - reference).XYZ(mid.Height),
(start.Position - reference).XYZ(start.Height)));
}
else if (!startEnabled && endEnabled)
{
triangleMesh.AddTriangle(new Triangle(
(end.Position - reference).XYZ(end.Height),
(mid.Position - reference).XYZ(mid.Height),
(Center.Position - reference).XYZ(Center.Height)));
}
}
public void Triangulate(TriangleMesh mesh, Vector2 reference)
{
if (!CornerReference[0]) return;
Corner lowerLeft = Corner[0];
Corner left = Corner[1];
Corner upperLeft = Corner[2];
Corner top = Corner[3];
Corner upperRight = Corner[4];
Corner right = Corner[5];
Corner lowerRight = Corner[6];
Corner bottom = Corner[7];
bool refLowerLeft = CornerReference[1];
bool refUpperLeft = CornerReference[2];
bool refUpperRight = CornerReference[3];
bool refLowerRight = CornerReference[4];
Evaluate(mesh, lowerLeft, bottom, lowerRight, refLowerLeft, bottom.Enabled, refLowerRight, reference);
Evaluate(mesh, upperLeft, left, lowerLeft, refUpperLeft, left.Enabled, refLowerLeft, reference);
Evaluate(mesh, upperRight, top, upperLeft, refUpperRight, top.Enabled, refUpperLeft, reference);
Evaluate(mesh, lowerRight, right, upperRight, refLowerRight, right.Enabled, refUpperRight, reference);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// call LoadContent on all used components that implement it.
testRasterizer.loadContent(GraphicsDevice, Content);
// Load a triangle mesh.
testMesh = new TriangleMesh("imrod_walk_high", Content);
// Create a BFSOctree out of that mesh.
testObj = new Object3D(testMesh.toBFSOctree(7), false);
// Store the octree into a binary file.
//testObj.getData().export("imrod.asvo");
testObj.rotate(Vector3.UnitX, MathHelper.PiOver2);
System.GC.Collect();
ks = Keyboard.GetState();
}
public void SerializationXml()
{
var a = new TriangleMesh();
a.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), true);
a.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), true);
// Serialize object.
var stream = new MemoryStream();
var serializer = new XmlSerializer(typeof(TriangleMesh));
serializer.Serialize(stream, a);
// Output generated xml. Can be manually checked in output window.
stream.Position = 0;
var xml = new StreamReader(stream).ReadToEnd();
Trace.WriteLine("Serialized Object:\n" + xml);
// Deserialize object.
stream.Position = 0;
var deserializer = new XmlSerializer(typeof(TriangleMesh));
var b = (TriangleMesh)deserializer.Deserialize(stream);
Assert.AreEqual(a.NumberOfTriangles, b.NumberOfTriangles);
for (int i = 0; i < a.Vertices.Count; i++)
Assert.AreEqual(a.Vertices[i], b.Vertices[i]);
for (int i = 0; i < a.Indices.Count; i++)
Assert.AreEqual(a.Indices[i], b.Indices[i]);
}
public void GetTriangle()
{
Triangle t1 = new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 1));
TriangleMesh mesh = new TriangleMesh();
mesh.Add(t1, false);
var t2 = mesh.GetTriangle(0);
Assert.AreEqual(t1.Vertex0, t2.Vertex0);
Assert.AreEqual(t1.Vertex1, t2.Vertex1);
Assert.AreEqual(t1.Vertex2, t2.Vertex2);
}
protected override void shown()
{
try
{
root = new RootDisposable();
// video objects
VideoTypes videoType;
#if METRO
VideoTypes createVideoTypes = VideoTypes.D3D11;
#elif WIN32
VideoTypes createVideoTypes = VideoTypes.D3D11 | VideoTypes.D3D9 | VideoTypes.OpenGL;
#elif XNA
VideoTypes createVideoTypes = VideoTypes.XNA;
#endif
#if WIN32 || METRO
video = Video.Init(createVideoTypes, out videoType, root, this, true);
#elif XNA
video = Video.Create(createVideoTypes, out videoType, root, this);
#endif
// shaders
DiffuseTextureMaterial.Init(video, "Data/", video.FileTag, ShaderVersions.Max, null);
DiffuseTextureMaterial.ApplyInstanceConstantsCallback = applyDiffuseCallbackMethod;
QuickDraw3ColorMaterial.Init(video, "Data/", video.FileTag, ShaderVersions.Max, null);
material = new QuickDraw3ColorMaterial();
texture = Texture2DAPI.New(video, "Data/Rocks.dds", null);
qd = QuickDrawAPI.New(video, QuickDraw3ColorMaterial.BufferLayoutDesc);
var frame = FrameSize;
viewPort = ViewPortAPI.New(video, 0, 0, frame.Width, frame.Height);
float camDis = 50;
camera = new Camera(viewPort, new Vector3(0, 5, camDis), new Vector3(), new Vector3(0, 5+1, camDis));
// states
rasterizerState = RasterizerStateAPI.New(video, RasterizerStateDescAPI.New(RasterizerStateTypes.Solid_CullCW));
samplerState = SamplerStateAPI.New(video, SamplerStateDescAPI.New(SamplerStateTypes.Linear_Wrap));
blendState = BlendStateAPI.New(video, BlendStateDescAPI.New(BlendStateTypes.None));
depthStencilState = DepthStencilStateAPI.New(video, DepthStencilStateDescAPI.New(DepthStencilStateTypes.ReadWrite_Less));
// models
var materialTypes = new Dictionary<string,Type>();
materialTypes.Add("Material", typeof(DiffuseTextureMaterial));
var materialFieldTypes = new List<MaterialFieldBinder>();
materialFieldTypes.Add(new MaterialFieldBinder("Material", "Paint_dds", "Diffuse"));
var extOverrides = new Dictionary<string,string>();
var emptyBinders = new List<MaterialFieldBinder>();
sphereModel = new Model(video, "Data/sphere.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides, 0, null);
//capsuleModel = Model.Create(videoType, video, "Data/capsule.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides);
boxModel = new Model(video, "Data/box.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides, 0, null);
monkeyModel = new Model(video, "Data/monkeyFlat.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides, 0, null);
// physics
collisionSystem = new CollisionSystemPersistentSAP();
world = new World(collisionSystem);
world.Gravity = new JVector(0, -9.81f, 0);
spheres = new RigidBody[35];
for (int i = 0; i != spheres.Length; ++i)
{
spheres[i] = new RigidBody(new SphereShape(1));
spheres[i].Position = new JVector(spheres.Length/(float)(i+1), (i*3)+5, 0);
world.AddBody(spheres[i]);
}
floorBox = new RigidBody(new BoxShape(30, 1, 30));
floorBox.Shape.TransformScale = new Vector3(30, 1, 30) * .5f;
floorBox.Position = new JVector(0, -7, 0);
floorBox.IsStatic = true;
//floorBox.Orientation = JMatrix.CreateFromYawPitchRoll(0, -.25f, 0);
world.AddBody(floorBox);
triangleMesh = new TriangleMesh("Data/monkeyFlat.rtmm", loadTiangleMesh);
loaded = true;
}
catch (Exception e)
{
Message.Show("Error", e.Message);
dispose();
}
}
