public void Triangulating_polygons()
{
var content =
@"v -1 1 0
v -1 0 0
v 1 0 0
v 1 1 0
v 0 2 0
f 1 2 3 4 5";
var result = ObjFileParser.Parse(content);
result.DefaultGroup.Shapes.Count.Should().Be(3);
var triangle1 = (Triangle)result.DefaultGroup.Shapes[0];
triangle1.P1.Should().Be(result.Vertices[1]);
triangle1.P2.Should().Be(result.Vertices[2]);
triangle1.P3.Should().Be(result.Vertices[3]);
var triangle2 = (Triangle)result.DefaultGroup.Shapes[1];
triangle2.P1.Should().Be(result.Vertices[1]);
triangle2.P2.Should().Be(result.Vertices[3]);
triangle2.P3.Should().Be(result.Vertices[4]);
var triangle3 = (Triangle)result.DefaultGroup.Shapes[2];
triangle3.P1.Should().Be(result.Vertices[1]);
triangle3.P2.Should().Be(result.Vertices[4]);
triangle3.P3.Should().Be(result.Vertices[5]);
}
public void TrianglesInGroups()
{
var input = @"
v -1 1 0
v -1 0 0
v 1 0 0
v 1 1 0
g FirstGroup
f 1 2 3
g SecondGroup
f 1 3 4
";
var reader = new StringReader(input);
var parser = new ObjFileParser(reader);
var g1 = parser["FirstGroup"];
var g2 = parser["SecondGroup"];
var t1 = g1[0] as Triangle;
var t2 = g2[0] as Triangle;
Assert.AreEqual(t1.P1, parser.Vertices[0]);
Assert.AreEqual(t1.P2, parser.Vertices[1]);
Assert.AreEqual(t1.P3, parser.Vertices[2]);
Assert.AreEqual(t2.P1, parser.Vertices[0]);
Assert.AreEqual(t2.P2, parser.Vertices[2]);
Assert.AreEqual(t2.P3, parser.Vertices[3]);
}
public void FacesWithNormals()
{
var content =
@"v 0 1 0
v -1 0 0
v 1 0 0
vn -1 0 0
vn 1 0 0
vn 0 1 0
f 1//3 2//1 3//2
f 1/0/3 2/102/1 3/14/2";
var parser = ObjFileParser.Parse(content);
var g = parser.DefaultGroup;
var t1 = (SmoothTriangle)g.Shapes[0];
var t2 = (SmoothTriangle)g.Shapes[1];
t1.P1.Should().Be(parser.Vertices[1]);
t1.P2.Should().Be(parser.Vertices[2]);
t1.P3.Should().Be(parser.Vertices[3]);
t1.N1.Should().Be(parser.Normals[3]);
t1.N2.Should().Be(parser.Normals[1]);
t1.N3.Should().Be(parser.Normals[2]);
t2.P1.Should().Be(parser.Vertices[1]);
t2.P2.Should().Be(parser.Vertices[2]);
t2.P3.Should().Be(parser.Vertices[3]);
t2.N1.Should().Be(parser.Normals[3]);
t2.N2.Should().Be(parser.Normals[1]);
t2.N3.Should().Be(parser.Normals[2]);
}
public SceneBuilder(string input, int width, int height, string floor, double rX, double rY, double rZ)
{
bool withFloor = !string.IsNullOrWhiteSpace(floor);
world = new World();
world.Lights.Add(new PointLight(new Point(0, 0, 10), Color.White));
var parser = new ObjFileParser(input);
var obj = parser.ObjToGroup;
obj.Transform = Matrix.Translation(0, withFloor ? parser.Center.y - parser.Min.y : 0, 0)
* Matrix.RotationZ(rZ)
* Matrix.RotationX(rX)
* Matrix.RotationY(rY);
world.Objects.Add(obj);
double fov = Math.PI / 3;
double fromX, fromY, fromZ;
double toX, toY, toZ;
if (withFloor)
{
var flr = new Plane();
flr.Material.Color = GetObjColor(floor);
flr.Material.Diffuse = 0.1;
flr.Material.Specular = 0.9;
flr.Material.Shininess = 300;
flr.Material.Reflective = 0.5;
world.Objects.Add(flr);
fromX = 0.0;
fromY = 0.1;
fromZ = 10;
toX = 0.0;
toY = 0.5;
toZ = 0.0;
}
else
{
var hght = Math.Max(parser.Max.x - parser.Min.x, Math.Max(parser.Max.y - parser.Min.y, parser.Max.z - parser.Min.z));
var dist = Math.Abs(hght / Math.Sin(fov / 2));
var center = parser.Center;
fromX = center.x;
fromY = center.y;
fromZ = dist + hght;
toX = center.x;
toY = center.y;
toZ = center.z;
}
camera = new Camera(width, height, fov);
camera.Transform = Matrix.ViewTransform(new Point(fromX, fromY, fromZ),
new Point(toX, toY, toZ),
Vector.VectorY);
ObjFile = true;
}
public void TestObjFileNormalVertex()
{
var parser = new ObjFileParser(@"..\..\..\..\..\ObjFiles\NormalVertexTest.obj");
Assert.AreEqual(parser.Normals[1], new Vector(0, 0, 1));
Assert.AreEqual(parser.Normals[2], new Vector(0.707, 0, -0.707));
Assert.AreEqual(parser.Normals[3], new Vector(1, 2, 3));
}
public void TestObjFileConvertToGroup()
{
var parser = new ObjFileParser(@"..\..\..\..\..\ObjFiles\TrianglesTest.obj");
var g = parser.ObjToGroup;
Assert.IsTrue(g.Contains(parser.Groups[0]));
Assert.IsTrue(g.Contains(parser.Groups[1]));
}
public void TestObjFileVertexRecords()
{
var parser = new ObjFileParser(@"..\..\..\..\..\ObjFiles\VertexTest.obj");
Assert.AreEqual(parser.Vertices[1], new Point(-1, 1, 0));
Assert.AreEqual(parser.Vertices[2], new Point(-1, 0.5, 0));
Assert.AreEqual(parser.Vertices[3], new Point(1, 0, 0));
Assert.AreEqual(parser.Vertices[4], new Point(1, 1, 0));
}
private RTObject BuildAddObj(Values item)
{
var file = item["file"];
var parser = new ObjFileParser(file.String);
var obj = parser.ObjToGroup;
BuildShape(obj, item);
return(obj);
}
public void Converting_an_OBJ_file_to_a_group()
{
var path = Path.Combine(_objFilesDir, "triangles.obj");
var parser = ObjFileParser.ParseFromFile(path);
var bundlingGroup = parser.BundlingGroup;
bundlingGroup.Shapes.Should().Contain(parser.GetGroup("FirstGroup"));
bundlingGroup.Shapes.Should().Contain(parser.GetGroup("SecondGroup"));
}
public void Vertex_normal_records()
{
var content =
@"vn 0 0 1
vn 0.707 0 -0.707
vn 1 2 3";
var parser = ObjFileParser.Parse(content);
parser.Normals[1].Should().Be(Tuple.Vector(0, 0, 1));
parser.Normals[2].Should().Be(Tuple.Vector(0.707, 0, -0.707));
parser.Normals[3].Should().Be(Tuple.Vector(1, 2, 3));
}
public void Ignoring_unrecognized_lines()
{
var gibberish =
@"There was a young lady named Bright
who traveled much faster than light.
She set out one day
in a relative way,
and came back the previous night.";
var result = ObjFileParser.Parse(gibberish);
result.NumberIgnoredLines.Should().Be(5);
}
public void VertexNormalRecords()
{
var input = @"
vn 0 0 1
vn 0.707 0 -0.707
vn 1 2 3";
var reader = new StringReader(input);
var parser = new ObjFileParser(reader);
Assert.AreEqual(new Vector(0, 0, 1), parser.Normals[0]);
Assert.AreEqual(new Vector(0.707, 0, -0.707), parser.Normals[1]);
Assert.AreEqual(new Vector(1, 2, 3), parser.Normals[2]);
}
public void IgnoringUnrecognizedLines()
{
var input = @"
There was a young lady named Bright
Who travelled much faster than light
She set out one day
In a relative way
And returned home the previous night
";
var reader = new StringReader(input);
var parser = new ObjFileParser(reader);
Assert.AreEqual(5, parser.Ignored);
}
public void TestObjFileFaces()
{
var parser = new ObjFileParser(@"..\..\..\..\..\ObjFiles\FacesTest.obj");
Group g = parser.DefaultGroup;
var t1 = g[0] as Triangle;
var t2 = g[1] as Triangle;
Assert.AreEqual(t1.P1, parser.Vertices[1]);
Assert.AreEqual(t1.P2, parser.Vertices[2]);
Assert.AreEqual(t1.P3, parser.Vertices[3]);
Assert.AreEqual(t2.P1, parser.Vertices[1]);
Assert.AreEqual(t2.P2, parser.Vertices[3]);
Assert.AreEqual(t2.P3, parser.Vertices[4]);
}
public void TestObjFileNormalFaces()
{
var parser = new ObjFileParser(@"..\..\..\..\..\ObjFiles\NormalFacesTest.obj");
Group g = parser.DefaultGroup;
var t1 = g[0] as SmoothTriangle;
var t2 = g[1] as SmoothTriangle;
Assert.AreEqual(t1.P1, parser.Vertices[1]);
Assert.AreEqual(t1.P2, parser.Vertices[2]);
Assert.AreEqual(t1.P3, parser.Vertices[3]);
Assert.AreEqual(t1.N1, parser.Normals[3]);
Assert.AreEqual(t1.N2, parser.Normals[1]);
Assert.AreEqual(t1.N3, parser.Normals[2]);
Assert.AreEqual(t2, t1);
}
public void Vertex_records()
{
var content =
@"v -1 1 0
v -1.0000 0.5000 0.0000
v 1 0 0
v 1 1 0";
var result = ObjFileParser.Parse(content);
result.Vertices.Count.Should().Be(5); // One dummy a index 0
result.Vertices[1].Should().Be(Tuple.Point(-1, 1, 0));
result.Vertices[2].Should().Be(Tuple.Point(-1, 0.5, 0));
result.Vertices[3].Should().Be(Tuple.Point(1, 0, 0));
result.Vertices[4].Should().Be(Tuple.Point(1, 1, 0));
}
public void VertexData()
{
var input = @"
v -1 1 0
v -1.000 0.5000 0.000
v 1 0 0
v 1 1 0
";
var reader = new StringReader(input);
var parser = new ObjFileParser(reader);
Assert.AreEqual(new Point(-1, 1, 0), parser.Vertices[0]);
Assert.AreEqual(new Point(-1, 0.5, 0), parser.Vertices[1]);
Assert.AreEqual(new Point(1, 0, 0), parser.Vertices[2]);
Assert.AreEqual(new Point(1, 1, 0), parser.Vertices[3]);
}
//___________________________________________________________________
#region cilindro
public ObjetoGrafico crearCilindro()
{
DoublyConectedEdgeList l;
String ubicacion;
ObjFileParser parserPrueba;
ObjetoGrafico obj;
Vector3 traslacion = new Vector3(0.0f, 1.0f, 1.0f);
traslaciones.Add(traslacion);
l = new DoublyConectedEdgeList();
ubicacion = "C:/Users/Agus/Documents/Ejercicio1/cubo2.obj";
parserPrueba = new ObjFileParser(l, ubicacion);
l.mostrarfigura();
Vector3 color = new Vector3(0.0f, 0.0f, 1.0f);
obj = new ObjetoGrafico(l, color);
return(obj);
}
public void Triangles_in_named_groups()
{
var path = Path.Combine(_objFilesDir, "triangles.obj");
var parser = ObjFileParser.ParseFromFile(path);
var group1 = parser.GetGroup("FirstGroup");
var triangle1 = (Triangle)group1.Shapes[0];
triangle1.P1.Should().Be(parser.Vertices[1]);
triangle1.P2.Should().Be(parser.Vertices[2]);
triangle1.P3.Should().Be(parser.Vertices[3]);
var group2 = parser.GetGroup("SecondGroup");
var triangle2 = (Triangle)group2.Shapes[0];
triangle2.P1.Should().Be(parser.Vertices[1]);
triangle2.P2.Should().Be(parser.Vertices[3]);
triangle2.P3.Should().Be(parser.Vertices[4]);
}
public ObjetoGrafico crear(string u, Vector3 posicion, Vector3 rotacion, Vector3 c)
{
DoublyConectedEdgeList l;
String ubicacion;
ObjFileParser parserPrueba;
ObjetoGrafico obj;
Vector3 traslacion = posicion;
l = new DoublyConectedEdgeList();
ubicacion = u;
parserPrueba = new ObjFileParser(l, u);
l.setTraslacion(posicion);
l.setRotacion(rotacion);
Vector3 color = c;
l.setColor(color);
obj = new ObjetoGrafico(l, color);
return(obj);
}
public void Parsing_triangle_faces()
{
var content =
@"v -1 1 0
v -1 0 0
v 1 0 0
v 1 1 0
f 1 2 3
f 1 3 4";
var result = ObjFileParser.Parse(content);
var triangle1 = (Triangle)result.DefaultGroup.Shapes[0];
triangle1.P1.Should().Be(result.Vertices[1]);
triangle1.P2.Should().Be(result.Vertices[2]);
triangle1.P3.Should().Be(result.Vertices[3]);
var triangle2 = (Triangle)result.DefaultGroup.Shapes[1];
triangle2.P1.Should().Be(result.Vertices[1]);
triangle2.P2.Should().Be(result.Vertices[3]);
triangle2.P3.Should().Be(result.Vertices[4]);
}
public void TestObjFileIgnoreGibberish()
{
var parser = new ObjFileParser(@"..\..\..\..\..\ObjFiles\GibberishTest.obj");
Assert.AreEqual(parser.Ignored, 5);
}
static void Main(string[] args)
{
// True puts object on floor; False centers camera on object without floor.
bool withFloor = true;
Console.WriteLine("Generating an ObjFile Rendering!");
var dt = DateTime.Now;
Console.WriteLine($"Starting: {dt}");
// Floor
var floor = new Plane();
floor.Material.Color = Color.Red;
floor.Material.Diffuse = 0.1;
floor.Material.Specular = 0.9;
floor.Material.Shininess = 300;
floor.Material.Reflective = 0.5;
var parser = new ObjFileParser(@"..\..\..\..\..\..\ObjFiles\teapot.obj", withFloor);
var group = parser.ObjToGroup;
group.Transform = Matrix.Translation(0, withFloor ? parser.Center.y - parser.Min.y : 0, 0)
//* Matrix.RotationZ(Math.PI / 2)
//* Matrix.RotationX(-Math.PI / 2)
//* Matrix.RotationY(Math.PI / 2)
;
int threshold = (int)group.Count / 4;
if (threshold < 1)
{
threshold = 1;
}
//group.Divide(1500);
var time = DateTime.Now - dt;
Console.WriteLine($"Loading: {time.Hours}:{time.Minutes}:{time.Seconds}");
var world = new World();
world.Lights.Add(new PointLight(new Point(0, 0, 10), Color.White));
world.Objects.Add(group);
double fov = Math.PI / 3;
double fromX, fromY, fromZ;
double toX, toY, toZ;
if (withFloor)
{
world.Objects.Add(floor);
fromX = 0.0;
fromY = 0.1;
fromZ = 10;
toX = 0.0;
toY = 0.5;
toZ = 0.0;
}
else
{
var height = Math.Max(parser.Max.x - parser.Min.x, Math.Max(parser.Max.y - parser.Min.y, parser.Max.z - parser.Min.z));
var dist = Math.Abs(height / Math.Sin(fov / 2));
var center = parser.Center;
fromX = center.x;
fromY = center.y;
fromZ = dist + height;
toX = center.x;
toY = center.y;
toZ = center.z;
}
var camera = new Camera(400, 200, fov);
camera.Transform = Matrix.ViewTransform(new Point(fromX, fromY, fromZ),
new Point(toX, toY, toZ),
Vector.VectorY);
Console.WriteLine();
Console.WriteLine($"Minimum: {parser.Min}");
Console.WriteLine($"Maximum: {parser.Max}");
Console.WriteLine($"Center: {parser.Center}");
Console.WriteLine();
dt = DateTime.Now;
var c = camera.Render(world);
time = DateTime.Now - dt;
Console.WriteLine($"Rendering: {time.Hours}:{time.Minutes}:{time.Seconds}");
Console.WriteLine($"Finished: {DateTime.Now}");
System.IO.File.WriteAllText("ObjFile.ppm", c.GetPPM());
Console.WriteLine("Done!");
Console.ReadLine();
}
internal static StaticObject ReadObject(string FileName)
{
currentFolder = System.IO.Path.GetDirectoryName(FileName);
currentFile = FileName;
#if !DEBUG
try
{
#endif
ObjFileParser parser = new ObjFileParser(System.IO.File.ReadAllLines(currentFile), null, System.IO.Path.GetFileNameWithoutExtension(currentFile), currentFile);
Model model = parser.GetModel();
StaticObject obj = new StaticObject(Plugin.currentHost);
MeshBuilder builder = new MeshBuilder(Plugin.currentHost);
List <Vertex> allVertices = new List <Vertex>();
foreach (var vertex in model.Vertices)
{
allVertices.Add(new Vertex(vertex));
}
List <Vector2> allTexCoords = new List <Vector2>();
foreach (var texCoord in model.TextureCoord)
{
allTexCoords.Add(new Vector2(texCoord.X, texCoord.Y));
}
List <Vector3> allNormals = new List <Vector3>();
foreach (var normal in model.Normals)
{
allNormals.Add(new Vector3(normal.X, normal.Y, normal.Z));
}
foreach (AssimpNET.Obj.Mesh mesh in model.Meshes)
{
foreach (Face face in mesh.Faces)
{
int nVerts = face.Vertices.Count;
if (nVerts == 0)
{
throw new Exception("nVertices must be greater than zero");
}
int v = builder.Vertices.Length;
Array.Resize(ref builder.Vertices, v + nVerts);
for (int i = 0; i < nVerts; i++)
{
builder.Vertices[v + i] = allVertices[(int)face.Vertices[i]];
}
int f = builder.Faces.Length;
Array.Resize(ref builder.Faces, f + 1);
builder.Faces[f] = new MeshFace();
builder.Faces[f].Vertices = new MeshFaceVertex[nVerts];
for (int i = 0; i < nVerts; i++)
{
builder.Faces[f].Vertices[i].Index = (ushort)i;
}
builder.Faces[f].Material = 1;
int m = builder.Materials.Length;
Array.Resize(ref builder.Materials, m + 1);
builder.Materials[m] = new OpenBveApi.Objects.Material();
uint materialIndex = mesh.MaterialIndex;
if (materialIndex != AssimpNET.Obj.Mesh.NoMaterial)
{
AssimpNET.Obj.Material material = model.MaterialMap[model.MaterialLib[(int)materialIndex]];
builder.Materials[m].Color = new Color32((byte)(255 * material.Diffuse.R), (byte)(255 * material.Diffuse.G), (byte)(255 * material.Diffuse.B), (byte)(255 * material.Diffuse.A));
#pragma warning disable 0219
//Current openBVE renderer does not support specular color
Color24 mSpecular = new Color24((byte)material.Specular.R, (byte)material.Specular.G, (byte)material.Specular.B);
#pragma warning restore 0219
builder.Materials[m].EmissiveColor = new Color24((byte)(255 * material.Emissive.R), (byte)(255 * material.Emissive.G), (byte)(255 * material.Emissive.B));
builder.Materials[m].EmissiveColorUsed = true; //TODO: Check exact behaviour
builder.Materials[m].TransparentColor = new Color24((byte)(255 * material.Transparent.R), (byte)(255 * material.Transparent.G), (byte)(255 * material.Transparent.B));
builder.Materials[m].TransparentColorUsed = true;
if (material.Texture != null)
{
builder.Materials[m].DaytimeTexture = OpenBveApi.Path.CombineFile(currentFolder, material.Texture);
if (!System.IO.File.Exists(builder.Materials[m].DaytimeTexture))
{
Plugin.currentHost.AddMessage(MessageType.Error, true, "Texure " + builder.Materials[m].DaytimeTexture + " was not found in file " + currentFile);
builder.Materials[m].DaytimeTexture = null;
}
}
}
int nCoords = face.TexturCoords.Count;
for (int i = 0; i < nCoords; i++)
{
builder.Vertices[i].TextureCoordinates = allTexCoords[(int)face.TexturCoords[i]];
}
int nNormals = face.Normals.Count;
Vector3[] normals = new Vector3[nNormals];
for (int i = 0; i < nNormals; i++)
{
normals[i] = allNormals[(int)face.Normals[i]];
normals[i].Normalize();
}
for (int i = 0; i < nNormals; i++)
{
builder.Faces[0].Vertices[i].Normal = normals[i];
}
builder.Apply(ref obj);
builder = new MeshBuilder(Plugin.currentHost);
}
}
obj.Mesh.CreateNormals();
return(obj);
#if !DEBUG
}
catch (Exception e)
{
Plugin.currentHost.AddMessage(MessageType.Error, false, e.Message + " in " + FileName);
return(null);
}
#endif
}
protected override void CreateScenery()
{
var parser = ObjFileParser.ParseFromFile("ObjFileParsing\\ObjFiles\\cow-nonormals.obj");
AddShapesToWorld(parser.BundlingGroup);
}
