private static ToolResult MergeObjFiles(List <string> fileList, string objOutput)
{
bool success = false;
StringBuilder sb = new StringBuilder();
if (fileList != null)
{
List <ObjData> objDatas = ObjParser.ParseObjs(fileList);
ObjData objData = ObjModifier.MergeObjFiles(objDatas);
if (objData != null)
{
success = ObjExporter.WriteObj(objData, objData.Mtl, objOutput, makeMtl: true, useExistingMtl: true);
sb.AppendLine($"Merged {objDatas.Count} obj files into one");
sb.Append(MessageBoxConstants.GetMessageExecutionCreation(success, objOutput));
}
else
{
sb.Append(MessageBoxConstants.MessageErrorMergeObj + MessageBoxConstants.MessageErrorExecution);
}
}
else
{
sb.Append(MessageBoxConstants.MessageErrorMergeObj + MessageBoxConstants.MessageNoFilesMerge);
}
return(new ToolResult(sb.ToString(), success));
}
private static ToolResult DeleteUnusedMaterialsObj(string objFile, string objOutput)
{
bool success = false;
string message = "";
ObjData objData = ObjParser.TryParseObj(objFile);
if (objData != null)
{
objData.UpdateMtlData();
MtlData mtlData = objData.Mtl;
if (mtlData != null)
{
ObjModifier.DeleteUnusedMaterials(objData, mtlData);
success = ObjExporter.WriteObj(objData, mtlData, objOutput, makeMtl: true, useExistingMtl: true);
message = MessageBoxConstants.GetMessageExecutionCreation(success, objOutput);
}
else
{
message = MessageBoxConstants.MessageErrorDeleteUnusedMaterials +
MessageBoxConstants.MessageMtlNotFound;
}
}
else
{
message = MessageBoxConstants.GetMessageExecutionErrorParse(objFile);
}
return(new ToolResult(message, success));
}
private static ToolResult ConvertObjToSmd(string objFile, string smdOutput, bool useTextureName)
{
bool success = false;
string message = "";
ObjData objData = ObjParser.TryParseObj(objFile);
if (objData != null)
{
objData.UpdateMtlData();
MtlData mtlData = objData.Mtl;
if (mtlData == null)
{
// No MTL means the SMD will use a default material name for all objects
useTextureName = false;
}
success = SmdExporter.WriteSmd(objData, mtlData, smdOutput, useTextureName);
message = MessageBoxConstants.GetMessageExecutionCreation(success, smdOutput);
}
else
{
message = MessageBoxConstants.GetMessageExecutionErrorParse(objFile);
}
return(new ToolResult(message, success));
}
public static void Main()
{
ObjParser parser = new ObjParser();
string data = "";
using (StreamReader str = new StreamReader("awp.obj"))
data = str.ReadToEnd();
Geometry geometry = parser.Parse(data);
Bitmap texture = new Bitmap("texture.jpg");
Mesh mesh = new Mesh(geometry, texture);
MeshRenderer win = new MeshRenderer(1920, 1280, mesh);
//settings go here
win.CameraDistance += 10;
win.AngleX += 5;
win.SavePath = "test.jpg";
win.CloseOnSaved = false; //will occupy a thread unil force finish
win.Run(30);
}
public RTSUnitModel(RTSRenderer renderer, Stream sModel, Texture2D tAnim)
{
// Create With The Animation Texture
AnimationTexture = tAnim;
// Parse The Model File
VertexPositionNormalTexture[] pVerts;
VertexPositionTexture[] verts;
int[] inds;
if (!ObjParser.TryParse(sModel, out pVerts, out inds, MODEL_READ_FLAGS))
{
throw new ArgumentException("Bad Model File Format");
}
// Reformat Vertices
verts = new VertexPositionTexture[pVerts.Length];
for (int i = 0; i < verts.Length; i++)
{
verts[i].Position = new Vector3((float)((i + 0.1) / AnimationTexture.Width), 0, 0);
verts[i].TextureCoordinate = pVerts[i].TextureCoordinate;
}
// Create Model Geometry
RTSModelHelper.CreateBuffers(renderer, verts, VertexPositionTexture.VertexDeclaration, inds, out vbModel, out ibModel, BufferUsage.WriteOnly);
}
void Start()
{
if (filter != null && obj != null)
{
filter.mesh = ObjParser.ParseObj(obj.text);
}
}
/// <summary>
/// Instantiates a spline from an individual OBJ file which contains a set of vertices representing the individual points of the spline.
/// </summary>
/// <param name="path">An OBJ file containing the points of the spline as vertices.</param>
public static Spline *MakeSpline(string path)
{
// Store newly created Spline
Spline spline = new Spline();
// Parse individual spline file.
ObjParser parser = new ObjParser(path);
// Spline Information
spline.Enabler = 1;
spline.SplineType = parser.GetSplineType();
spline.NumberOfVertices = (ushort)parser.Vertices.Count;
// Get vertices & calculate total length
SplineVertex[] vertices = MakeSplineVertices(ref parser);
spline.TotalSplineLength = vertices.Sum(x => x.DistanceToNextVertex);
// Write vertices to unmanaged memory
int structSize = Marshal.SizeOf(vertices[0]) * vertices.Length;
IntPtr splineVerticesPointer = Marshal.AllocHGlobal(structSize);
MarshalUtilities.StructureArrayToPointer(vertices, splineVerticesPointer);
spline.VertexList = (SplineVertex *)splineVerticesPointer;
// Write spline to unmanaged memory
int splineSize = Marshal.SizeOf(spline);
IntPtr splinePointer = Marshal.AllocHGlobal(splineSize);
Marshal.StructureToPtr(spline, splinePointer, true);
return((Spline *)splinePointer);
}
private static void TestCase04()
{
// Parsing triangle faces
var contents = "v -1 1 0" + NewLine +
"v -1 0 0" + NewLine +
"v 1 0 0" + NewLine +
"v 1 1 0" + NewLine +
"v 0 2 0" + NewLine +
NewLine +
"f 1 2 3 4 5";
var parser = new ObjParser();
parser.ParseObjFile(contents.ToCharArray());
Group g = parser.Groups["default"];
Assert.Equal(3, g.Shapes.Count);
Triangle t1 = g.Shapes[0] as Triangle;
Triangle t2 = g.Shapes[1] as Triangle;
Triangle t3 = g.Shapes[2] as Triangle;
Assert.NotNull(t1);
Assert.NotNull(t2);
Assert.NotNull(t3);
Assert.Equal(parser.Vertices[0], t1.P1);
Assert.Equal(parser.Vertices[1], t1.P2);
Assert.Equal(parser.Vertices[2], t1.P3);
Assert.Equal(parser.Vertices[0], t2.P1);
Assert.Equal(parser.Vertices[2], t2.P2);
Assert.Equal(parser.Vertices[3], t2.P3);
Assert.Equal(parser.Vertices[0], t3.P1);
Assert.Equal(parser.Vertices[3], t3.P2);
Assert.Equal(parser.Vertices[4], t3.P3);
}
private static void TestCase08()
{
// Faces with normals
var contents = "v 0 1 0" + NewLine +
"v -1 0 0" + NewLine +
"v 1 0 0" + NewLine +
NewLine +
"vn -1 0 0" + NewLine +
"vn 1 0 0" + NewLine +
"vn 0 1 0" + NewLine +
NewLine +
"f 1//3 2//1 3//2" + NewLine +
"f 1/0/3 2/102/1 3/14/2";
var parser = new ObjParser();
parser.ParseObjFile(contents.ToCharArray());
Group g = parser.Groups["default"];
Assert.Equal(2, g.Shapes.Count);
SmoothTriangle t1 = g.Shapes[0] as SmoothTriangle;
SmoothTriangle t2 = g.Shapes[1] as SmoothTriangle;
Assert.NotNull(t1);
Assert.NotNull(t2);
Assert.Equal(parser.Vertices[0], t1.P1);
Assert.Equal(parser.Vertices[1], t1.P2);
Assert.Equal(parser.Vertices[2], t1.P3);
Assert.Equal(parser.Normals[2], t1.N1);
Assert.Equal(parser.Normals[0], t1.N2);
Assert.Equal(parser.Normals[1], t1.N3);
Assert.Equal(t1, t2);
}
private static void TestCase05()
{
// Triangles in groups
using (StreamReader sr = File.OpenText(@"../mesh/triangles.obj"))
{
string contents = sr.ReadToEnd();
var parser = new ObjParser();
parser.ParseObjFile(contents.ToCharArray());
Group g1 = parser.Groups["FirstGroup"];
Group g2 = parser.Groups["SecondGroup"];
Assert.NotNull(g1);
Assert.NotNull(g2);
Triangle t1 = g1.Shapes[0] as Triangle;
Triangle t2 = g2.Shapes[0] as Triangle;
Assert.NotNull(t1);
Assert.NotNull(t2);
Assert.Equal(parser.Vertices[0], t1.P1);
Assert.Equal(parser.Vertices[1], t1.P2);
Assert.Equal(parser.Vertices[2], t1.P3);
Assert.Equal(parser.Vertices[0], t2.P1);
Assert.Equal(parser.Vertices[2], t2.P2);
Assert.Equal(parser.Vertices[3], t2.P3);
}
}
public void ParserDealingWithFacesWithNormals_ShouldParseNormalDataCorrectly()
{
var file =
@"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 = new ObjParser(file);
parser.Parse();
var g = (object)parser.Groups[0] as Group;
var t1 = (object)g[0] as SmoothTriangle;
var t2 = (object)g[1] as SmoothTriangle;
Assert.StrictEqual(t1.p1, parser.Vertices[0]);
Assert.StrictEqual(t1.p2, parser.Vertices[1]);
Assert.StrictEqual(t1.p3, parser.Vertices[2]);
Assert.StrictEqual(t1.n1, parser.Normals[2]);
Assert.StrictEqual(t1.n2, parser.Normals[0]);
Assert.StrictEqual(t1.n3, parser.Normals[1]);
//Assert.Equal(t2, t1);
}
private static ToolResult CopyUsedTexturesObj(string objFile, string outputDirectory, string textureDirectory)
{
bool success = false;
string message = "";
ObjData objData = ObjParser.TryParseObj(objFile);
if (objData != null)
{
objData.UpdateMtlData();
MtlData mtlData = objData.Mtl;
if (mtlData != null)
{
success = ObjModifier.CopyUsedTextures(mtlData, outputDirectory, textureDirectory);
message = MessageBoxConstants.GetMessageExecutionGeneric(success);
}
else
{
message = MessageBoxConstants.MessageErrorCopyTextures + MessageBoxConstants.MessageMtlNotFound;
}
}
else
{
message = MessageBoxConstants.GetMessageExecutionErrorParse(objFile);
}
return(new ToolResult(message, success));
}
public void ParsingFilesWithGroupNames_ShouldPutTrianglesInGivenGroups()
{
var file =
@"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 parser = new ObjParser(file);
parser.Parse();
var g1 = (object)parser.Groups[0] as Group;
var g2 = (object)parser.Groups[1] as Group;
Triangle t1 = (object)g1[0] as Triangle;
Triangle t2 = (object)g2[0] as Triangle;
Assert.Equal(t1.p1, parser.Vertices[0]);
Assert.Equal(t1.p2, parser.Vertices[1]);
Assert.Equal(t1.p3, parser.Vertices[2]);
Assert.Equal(t2.p1, parser.Vertices[0]);
Assert.Equal(t2.p2, parser.Vertices[2]);
Assert.Equal(t2.p3, parser.Vertices[3]);
}
static void Main()
{
var renderer = new Renderer();
var game = new Game(renderer);
var vertShaderString = File.ReadAllText("Assets/Shaders/basic.vert");
var fragShaderString = File.ReadAllText("Assets/Shaders/basic.frag");
RawModel model;
using (var reader = new StreamReader("Assets/Models/dragon.obj"))
{
model = new RawModel(ObjParser.LoadModel(reader));
}
var textureData = new ImageSharpTexture("Assets/Textures/white.png");
var shaderSet = new ShaderSet(vertShaderString, fragShaderString);
renderer.Initialize(true);
var mesh = renderer.CreateMesh(model, textureData, shaderSet);
var entity = new RenderableEntity(new Transform(new Vector3(0, -5, -10), new Vector3(), 1), mesh);
entity.InitializeMesh(renderer);
game.AddEntity(entity);
game.AddEntity(new CameraController());
game.RunMainLoop();
renderer.DisposeGraphicsDevices();
}
public void ParsingPolygons_ShouldBreakApartIntoTriangles()
{
var file =
@"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 parser = new ObjParser(file);
parser.Parse();
var g = (object)parser.Groups[0] as Group;
Triangle t1 = (object)g[0] as Triangle;
Triangle t2 = (object)g[1] as Triangle;
Triangle t3 = (object)g[2] as Triangle;
Assert.Equal(t1.p1, parser.Vertices[0]);
Assert.Equal(t1.p2, parser.Vertices[1]);
Assert.Equal(t1.p3, parser.Vertices[2]);
Assert.Equal(t2.p1, parser.Vertices[0]);
Assert.Equal(t2.p2, parser.Vertices[2]);
Assert.Equal(t2.p3, parser.Vertices[3]);
Assert.Equal(t3.p1, parser.Vertices[0]);
Assert.Equal(t3.p2, parser.Vertices[3]);
Assert.Equal(t3.p3, parser.Vertices[4]);
}
public void ParserWithMulitpleGroups_ShouldPutFacesIntoGroupsAndCorrectCalcBounds()
{
var file =
@"v 0 0 0
v 0 0 4
v 0 4 0
v 0 4 4
v 4 0 0
v 4 4 0
v 4 0 4
v 4 4 4
g subgroup1
f 1 2 3
g subgroup2
f 1 2 4";
var parser = new ObjParser(file);
parser.Parse();
parser.Normalize();
var group = new Group();
group.AddShapes(parser.Groups);
Assert.Equal(new Point(-1, -1, -1), group.GetBounds().Min, PointComparer);
Assert.Equal(new Point(-1, 1, 1), group.GetBounds().Max, PointComparer);
}
public AreaTriggerManager(IGameContext gameContext)
{
this.gameContext = gameContext;
boxMesh = gameContext.Engine.MeshManager.CreateMesh(ObjParser.LoadObj("meshes/box.obj").MeshData);
sphereMesh = gameContext.Engine.MeshManager.CreateMesh(ObjParser.LoadObj("meshes/sphere.obj").MeshData);
wireframe = gameContext.Engine.MaterialManager.CreateMaterial("data/wireframe.json");
wireframe.SetUniform("Width", 1);
wireframe.SetUniform("Color", Vector4.One);
wireframe.ZWrite = false;
wireframe.DepthTesting = DepthCompare.Lequal;
wireframeBehind = gameContext.Engine.MaterialManager.CreateMaterial("data/wireframe.json");
wireframeBehind.SetUniform("Width", 0.5f);
wireframeBehind.SetUniform("Color", new Vector4(1, 1, 1, 0.1f));
wireframeBehind.ZWrite = false;
wireframeBehind.DepthTesting = DepthCompare.Greater;
wireframeBehind.BlendingEnabled = true;
wireframeBehind.SourceBlending = Blending.SrcAlpha;
wireframeBehind.DestinationBlending = Blending.OneMinusSrcAlpha;
transcluentMaterial = gameContext.Engine.MaterialManager.CreateMaterial("data/gizmo.json");
transcluentMaterial.BlendingEnabled = true;
transcluentMaterial.SourceBlending = Blending.SrcAlpha;
transcluentMaterial.DestinationBlending = Blending.OneMinusSrcAlpha;
transcluentMaterial.DepthTesting = DepthCompare.Lequal;
transcluentMaterial.ZWrite = false;
transcluentMaterial.SetUniform("objectColor", new Vector4(0.2f, 0.4f, 1f, 0.3f));
}
public LightingManager(IGameContext gameContext,
IGameProperties gameProperties,
IMeshManager meshManager,
IMaterialManager materialManager,
ITextureManager textureManager,
IRenderManager renderManager,
CameraManager cameraManager,
LightStore lightStore,
ILightManager lightManager,
TimeManager timeManager)
{
this.gameContext = gameContext;
this.gameProperties = gameProperties;
this.meshManager = meshManager;
this.textureManager = textureManager;
this.renderManager = renderManager;
this.cameraManager = cameraManager;
this.lightStore = lightStore;
this.lightManager = lightManager;
this.timeManager = timeManager;
skySphereMesh = meshManager.CreateMesh(ObjParser.LoadObj("meshes/skysphere.obj").MeshData);
skyMaterial = materialManager.CreateMaterial("data/skybox.json");
noiseTexture = textureManager.LoadTexture("textures/noise_512.png");
skyMaterial.SetTexture("cloudsTex", noiseTexture);
}
public LightingManager(IGameContext gameContext)
{
this.gameContext = gameContext;
skySphereMesh = gameContext.Engine.MeshManager.CreateMesh(ObjParser.LoadObj("meshes/skysphere.obj").MeshData);
skyMaterial = gameContext.Engine.MaterialManager.CreateMaterial("data/skybox.json");
noiseTexture = gameContext.Engine.TextureManager.LoadTexture("textures/noise_512.png");
skyMaterial.SetTexture("cloudsTex", noiseTexture);
}
public override ConstructedMeshInfo Load(Stream s)
{
using (var sr = new StreamReader(s))
{
string[] lines = sr.ReadToEnd().Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
var objFile = new ObjParser().Parse(lines);
return(objFile.GetFirstMesh());
}
}
public override ConstructedMeshInfo Load(Stream s)
{
using (var sr = new StreamReader(s))
{
string text = sr.ReadToEnd();
var objFile = new ObjParser().Parse(text);
return(objFile.GetFirstMesh());
}
}
public override ObjFile Load(Stream s)
{
using (var sr = new StreamReader(s))
{
string text = sr.ReadToEnd();
var objFile = new ObjParser().Parse(text);
return(objFile);
}
}
public void Test_LoadObj()
{
Assert.True(System.IO.File.Exists(objFile), "obj file does not exist!");
using (var parser = new ObjParser(objFile))
{
var model = parser.GetModel();
Assert.True(model.Vertices.Count > 0);
}
}
public Data(string basePath)
{
var parser = new ObjParser("main_red.o");
LoadHeaderData(basePath);
NormalizeMapData(LoadMapData(parser, _headers));
RenameMapData();
LoadTextPointers(basePath);
}
private void AddSponzaAtriumObjects()
{
ObjParser parser = new ObjParser();
using (FileStream objStream = File.OpenRead(AssetHelper.GetPath("Models/SponzaAtrium/sponza.obj")))
{
ObjFile atriumFile = parser.Parse(objStream);
MtlFile atriumMtls;
using (FileStream mtlStream = File.OpenRead(AssetHelper.GetPath("Models/SponzaAtrium/sponza.mtl")))
{
atriumMtls = new MtlParser().Parse(mtlStream);
}
foreach (ObjFile.MeshGroup group in atriumFile.MeshGroups)
{
Vector3 scale = new Vector3(0.1f);
ConstructedMeshInfo mesh = atriumFile.GetMesh(group);
MaterialDefinition materialDef = atriumMtls.Definitions[mesh.MaterialName];
ImageSharpTexture overrideTextureData = null;
ImageSharpTexture alphaTexture = null;
MaterialPropsAndBuffer materialProps = CommonMaterials.Brick;
if (materialDef.DiffuseTexture != null)
{
string texturePath = AssetHelper.GetPath("Models/SponzaAtrium/" + materialDef.DiffuseTexture);
overrideTextureData = LoadTexture(texturePath, true);
}
if (materialDef.AlphaMap != null)
{
string texturePath = AssetHelper.GetPath("Models/SponzaAtrium/" + materialDef.AlphaMap);
alphaTexture = LoadTexture(texturePath, false);
}
if (materialDef.Name.Contains("vase"))
{
materialProps = CommonMaterials.Vase;
}
if (group.Name == "sponza_117")
{
MirrorMesh.Plane = Plane.CreateFromVertices(
atriumFile.Positions[group.Faces[0].Vertex0.PositionIndex] * scale.X,
atriumFile.Positions[group.Faces[0].Vertex1.PositionIndex] * scale.Y,
atriumFile.Positions[group.Faces[0].Vertex2.PositionIndex] * scale.Z);
materialProps = CommonMaterials.Reflective;
}
AddTexturedMesh(
mesh,
overrideTextureData,
alphaTexture,
materialProps,
Vector3.Zero,
Quaternion.Identity,
scale,
group.Name);
}
}
}
static Dictionary <string, byte[]> LoadMapData(ObjParser parser, Dictionary <string, MapHeader> headers)
{
var ret = new Dictionary <string, byte[]>();
foreach (var header in headers.Values)
{
ret[header.MapData] = parser.CopySymbolData(header.MapData, header.Width * header.Height);
}
return(ret);
}
public void Test_Split()
{
Assert.True(System.IO.File.Exists(objFile), "obj file does not exist!");
using (var parser = new ObjParser(objFile))
{
var model = parser.GetModel();
var models = model.Split(2);
Assert.True(models.Count > 0);
}
}
public void RenderBasicScene()
{
var objFile = modelPath.ToString() + "utah_teapot_hires.obj";
FileStream instream = File.OpenRead(objFile);
StreamReader reader = new StreamReader(instream);
var objData = reader.ReadToEnd();
var parser = new ObjParser(objData);
parser.Parse();
var teapot = new Group();
teapot.AddShapes(parser.Groups);
teapot.Divide(200);
World world = new World();
world.Shapes = new List <Shape> {
teapot
};
// ======================================================
// light sources
// ======================================================
world.Lights = new List <ILight> {
new PointLight(new Point(-10, 10, -10), new Color(1, 1, 1))
};
// ======================================================
// the camera
// ======================================================
Camera camera = new Camera(400, 300, Math.PI / 2);
camera.Transform = Transformation.ViewTransform(
new Point(-1.5, 1.5, 0), // view from
new Point(0, 0.5, 0), // view to
new Vector(0, 1, 0)); // vector up
Canvas canvas = camera.Render(world);
string filename = imagePath.ToString() + "SmoothTeapot.ppm";
if (File.Exists(filename))
{
File.Delete(filename);
}
FileStream stream = File.OpenWrite(filename);
StreamWriter writer = new StreamWriter(stream);
PpmWriter.WriteCanvasToPpm(writer, canvas);
writer.Close();
}
public void ObjLoad_Tests()
{
var objFile = Path.Combine(SampleRootPath, "model/model.obj");
var objModel = ObjParser.Parse(objFile);
Assert.NotNull(objModel);
Assert.True(objModel.Groups.Count == 1);
Assert.Equal(92, objModel.Positions.Count);
Assert.Equal(19, objModel.Normals.Count);
Assert.Equal(32, objModel.TextureCoords.Count);
}
public void Cube_NormalsInATriangleAreTheSame()
{
var model = ObjParser.LoadModel(new StringReader(cubeData));
for (int i = 0; i < model.Indexes.Length; i += 3)
{
var normals = model.Normals;
var indexes = model.Indexes;
Assert.Equal(normals[indexes[i]], normals[indexes[i + 1]]); // First and second normal in a triangle should be the same.
Assert.Equal(normals[indexes[i]], normals[indexes[i + 2]]); // First and second normal in a triangle should be the same.
}
}
