public Geometry()
{
// Todo : This should not be necessary.
if (ObjectFactory.IsObjectFactoryInitialized)
{
GeometryContext = ObjectFactory.Instance.Get<IGeometryContext>();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PathMarkupParser"/> class.
/// </summary>
/// <param name="geometryContext">The geometry context.</param>
/// <exception cref="ArgumentNullException">geometryContext</exception>
public PathMarkupParser(IGeometryContext geometryContext)
{
if (geometryContext == null)
{
throw new ArgumentNullException(nameof(geometryContext));
}
_geometryContext = geometryContext;
}
protected override void Initialize()
{
// Todo : This should not be necessary.
if (null == GeometryContext)
{
GeometryContext = ObjectFactory.Instance.Get<IGeometryContext>();
}
base.Initialize();
}
protected virtual void Dispose(bool disposing)
{
if (_isDisposed)
{
return;
}
if (disposing)
{
_geometryContext = null;
}
_isDisposed = true;
}
private static void LoadTextureFaces(IGeometryContext context, IFormatProvider format, string data)
{
// *MESH_TFACE 0 0 5 6
var faceRegex = new Regex(@"\t\t\t\*MESH_TFACE\s*(\d*)\t([0-9]*)\t([0-9]*)\t([0-9]*)[\n\r]*");
var matches = faceRegex.Matches(data);
foreach (Match match in matches)
{
var faceIndex = Convert.ToInt32(match.Groups[1].Value);
var a = Convert.ToInt32(match.Groups[2].Value);
var b = Convert.ToInt32(match.Groups[3].Value);
var c = Convert.ToInt32(match.Groups[4].Value);
context.SetFaceTextureCoordinateIndex(faceIndex, a, b, c);
}
}
public static void CalculateFaceNormals(IGeometryContext context)
{
var vertices = context.GetVertices();
var faces = context.GetFaces();
for( var faceIndex=0; faceIndex<faces.Length; faceIndex++ )
{
var v1 = vertices[faces[faceIndex].A].Vector;
var v2 = vertices[faces[faceIndex].B].Vector;
var v3 = vertices[faces[faceIndex].C].Vector;
var cross = (v2 - v1).Cross(v3 - v1);
cross.Normalize();
faces[faceIndex].Normal = -cross;
}
}
private static void LoadVertices(IGeometryContext context, IFormatProvider format, string data)
{
var meshRegex = new Regex(@"\t\t\t\*MESH_VERTEX\s*(\d*)\t([\-\d\.]*)\t([\-\d\.]*)\t([\-\d\.]*)[\n\r]*");
var matches = meshRegex.Matches(data);
context.AllocateVertices(matches.Count);
var vertexIndex = 0;
foreach (Match match in matches)
{
var x = float.Parse(match.Groups[2].Value, format);
var z = float.Parse(match.Groups[3].Value, format);
var y = -float.Parse(match.Groups[4].Value, format);
context.SetVertex(vertexIndex, new Vertex(x, y, z));
vertexIndex++;
}
}
public static void CalculateVertexNormals(IGeometryContext context)
{
var vertexCount = new Dictionary<int, int>();
var vertexNormal = new Dictionary<int, Vector>();
var vertices = context.GetVertices();
var faces = context.GetFaces();
Func<int, Vector, int> addNormal =
delegate(int vertex, Vector normal)
{
if (!vertexNormal.ContainsKey(vertex))
{
vertexNormal[vertex] = normal;
vertexCount[vertex] = 1;
}
else
{
vertexNormal[vertex] += normal;
vertexCount[vertex]++;
}
return 0;
};
foreach (var face in faces)
{
addNormal(face.A, face.Normal);
addNormal(face.B, face.Normal);
addNormal(face.C, face.Normal);
}
foreach (var vertex in vertexNormal.Keys)
{
var addedNormals = vertexNormal[vertex];
var count = vertexCount[vertex];
var normal = new Vector(addedNormals.X / count,
addedNormals.Y / count,
addedNormals.Z / count);
vertices[vertex].Normal = normal;
}
}
public static void CalculateVertexNormals(IGeometryContext context)
{
var vertexCount = new Dictionary <int, int>();
var vertexNormal = new Dictionary <int, Vector>();
var vertices = context.GetVertices();
var faces = context.GetFaces();
Func <int, Vector, int> addNormal =
delegate(int vertex, Vector normal)
{
if (!vertexNormal.ContainsKey(vertex))
{
vertexNormal[vertex] = normal;
vertexCount[vertex] = 1;
}
else
{
vertexNormal[vertex] += normal;
vertexCount[vertex]++;
}
return(0);
};
foreach (var face in faces)
{
addNormal(face.A, face.Normal);
addNormal(face.B, face.Normal);
addNormal(face.C, face.Normal);
}
foreach (var vertex in vertexNormal.Keys)
{
var addedNormals = vertexNormal[vertex];
var count = vertexCount[vertex];
var normal = new Vector(addedNormals.X / count,
addedNormals.Y / count,
addedNormals.Z / count);
vertices[vertex].Normal = normal;
}
}
private static void LoadTextureCoordinates(IGeometryContext context, IFormatProvider format, string data)
{
var meshRegex = new Regex(@"\t\t\t\*MESH_TVERT\s*(\d*)\t([\-\d\.]*)\t([\-\d\.]*)\t([\-\d\.]*)[\n\r]*");
var matches = meshRegex.Matches(data);
context.AllocateTextureCoordinates(matches.Count);
var vertexIndex = 0;
foreach (Match match in matches)
{
var u = float.Parse(match.Groups[2].Value, format);
var v = float.Parse(match.Groups[3].Value, format);
v = 1f - v;
//var y = -float.Parse(match.Groups[4].Value, format);
context.SetTextureCoordinate(vertexIndex, new TextureCoordinate(u, v));
vertexIndex++;
}
}
private static void LoadFaces(IGeometryContext context, IFormatProvider format, string data, Material[] materials)
{
var faceRegex = new Regex(@"\t\t\t\*MESH_FACE\s*[0-9]*:\s*A:\s*([0-9]*)\s*B:\s*([0-9]*)\s*C:\s*([0-9]*)\s*AB:\s*([0-9]*)\s*BC:\s*([0-9]*)\s*CA:\s*([0-9]*)\t\s*\*MESH_SMOOTHING\s*[0-9]*\s*\t\*MESH_MTLID\s*([0-9]*)[\n\r]*");
var matches = faceRegex.Matches(data);
context.AllocateFaces(matches.Count);
var faceIndex = 0;
foreach (Match match in matches)
{
var a = Convert.ToInt32(match.Groups[1].Value);
var b = Convert.ToInt32(match.Groups[2].Value);
var c = Convert.ToInt32(match.Groups[3].Value);
var face = new Face {
A = a, B = b, C = c
};
/*
* var materialIndex = Convert.ToInt32(match.Groups[4].Value);
* if( materialIndex < materials.Length )
* {
* face.Material = materials[materialIndex];
* }
* */
if (materials.Length > 0)
{
face.Material = materials[0];
}
context.SetFace(faceIndex, face);
faceIndex++;
}
}
private Material[] LoadMaterials(string aseAssetName, IGeometryContext context, IFormatProvider format, string data)
{
var materials = new List <Material>();
var rootPath = Path.GetDirectoryName(aseAssetName);
var query = from match in RegexQuery.Against(data)
where match
.RegEx("\t")
.Literal("*MATERIAL")
.WhiteSpace
.Group(Pattern.With.Digit.Repeat.ZeroOrMore)
.WhiteSpace
.Literal("{")
.RegEx("[\n\r]*")
.IsTrue()
select match;
foreach (var match in query)
{
var materialEnd = data.IndexOf("\n\t}", match.Index);
if (materialEnd > 0)
{
materialEnd += 2;
var material = new Material();
materials.Add(material);
var materialString = data.Substring(match.Index, materialEnd - match.Index);
var diffuseIndex = materialString.IndexOf("\t\t*MAP_DIFFUSE");
if (diffuseIndex > 0)
{
var diffuseEnd = materialString.IndexOf("\n\t\t}", diffuseIndex);
if (diffuseEnd > 0)
{
var diffuseString = materialString.Substring(diffuseIndex, diffuseEnd - diffuseIndex);
var bitmapIndex = diffuseString.IndexOf("\t\t\t*BITMAP");
var eolIndex = diffuseString.IndexOf('\n', bitmapIndex);
if (eolIndex > 0)
{
var bitmapString = diffuseString.Substring(bitmapIndex, eolIndex - bitmapIndex);
var fileIndex = bitmapString.IndexOf('"');
if (fileIndex > 0)
{
var file = bitmapString.Substring(fileIndex + 1).Replace('"', ' ').Trim();
var relativeFile = Path.GetFileName(file);
var actualFile = string.IsNullOrEmpty(rootPath)
? relativeFile
: string.Format("{0}//{1}", rootPath, relativeFile);
var loader = _assetLoaderService.GetLoader <Image>(actualFile);
var frames = loader.Load(actualFile);
material.DiffuseMap = frames[0];
}
}
}
}
}
}
return(materials.ToArray());
/*
* var materialRegex = new Regex(@"\t\*MATERIAL\s*(\d*)\s*{[\n\r](.*)\t}");
* var matches = materialRegex.Matches(data);
*
* var assetName = "BlueEnvMap.png";
* var loader = AssetLoaderManager.Instance.GetLoader<Image>(assetName);
* var frames = loader.Load(assetName);
*
* var material = new Material
* {
* DiffuseMap = frames[0]
* };
*
* for (var faceIndex = 0; faceIndex < context.FaceCount; faceIndex++)
* {
* context.SetMaterial(faceIndex, material);
* }
*/
}
