protected void LoadVectorsOrNormals(Dictionary <string, VtkDataAttribute> attributes, int size)
{
VectorsOrNormals data;
if (_curToken == VtkToken.Vectors)
{
data = new Vectors();
}
else
{
data = new Normals();
}
data.Name = GetStringPart();
attributes[data.Name] = data;
var dtType = GetDataType();
Debug.WriteLine(string.Format("{2} name: {0}, dataType: {1}", data.Name, dtType, _curToken));
data.Values = new List <Vector3>(size);
for (int i = 0; i < size; i++)
{
var v = new Vector3();
v.X = GetDataAsFloat(dtType);
v.Y = GetDataAsFloat(dtType);
v.Z = GetDataAsFloat(dtType);
data.Values.Add(v);
}
}
/// <summary>
/// Generates the vertices, normals and indices and creates them for the OpenGL.
/// This method has to be called once before drawing.
/// </summary>
/// <param name="gl"></param>
public void GenerateGeometry(OpenGL gl, OGLModelUsage usage)
{
GL = gl;
_usage = usage;
// Create the data buffers.
var buffers = OGLBufferId.CreateBufferIds(gl, 3);
IndexBuffer = new IBO(buffers[0]);
NormalBuffer = new VBO(buffers[1]);
VertexBuffer = new VBO(buffers[2]);
if (AutoCalculateNormals)
{
CalculateNormals();
}
var vertData = Vertices.SelectMany(v => v.to_array()).ToArray();
VertexBuffer.BindBuffer(gl); // GL.BindBuffer(OpenGL.GL_ARRAY_BUFFER, VertexBuffer.Buffer.Value);
VertexBuffer.SetBufferData(gl, OGLBufferDataTarget.ArrayBuffer, vertData, usage, 3); // GL.BufferData(OpenGL.GL_ARRAY_BUFFER, vertData, (uint)usage);
var normData = Normals.SelectMany(v => v.to_array()).ToArray();
NormalBuffer.BindBuffer(gl); //GL.BindBuffer(OpenGL.GL_ARRAY_BUFFER, NormalBuffer.Buffer.Value);
NormalBuffer.SetBufferData(gl, OGLBufferDataTarget.ArrayBuffer, normData, usage, 3); // GL.BufferData(OpenGL.GL_ARRAY_BUFFER, normData, (uint)usage);
IndexBuffer.BindBuffer(gl); // GL.BindBuffer(OpenGL.GL_ARRAY_BUFFER, IndexBuffer.Buffer.Value);
IndexBuffer.SetBufferData(gl, OGLBufferDataTarget.ArrayBuffer, Indices, usage, 1); // GL.BufferData(OpenGL.GL_ARRAY_BUFFER, Indices, (uint)usage);
if (new OGLModelUsage[] { OGLModelUsage.StaticCopy, OGLModelUsage.StaticDraw, OGLModelUsage.StaticRead }.Contains(usage))
{
ClearStaticData();
}
}
public ObjFaceBuilder Clear()
{
Vertices.Clear();
Normals.Clear();
UVs.Clear();
return(this);
}
public void ReportGeometryTo(StringBuilder sb)
{
int i = 0;
var pEn = Positions.GetEnumerator();
var nEn = Normals.GetEnumerator();
while (pEn.MoveNext() && nEn.MoveNext())
{
var p = pEn.Current;
var n = nEn.Current;
sb.AppendFormat("{0} pos: {1} nrm:{2}\r\n", i++, p, n);
}
i = 0;
sb.AppendLine("Triangles:");
foreach (var item in TriangleIndices)
{
sb.AppendFormat("{0}, ", item);
i++;
if (i % 3 == 0)
{
sb.AppendLine();
}
}
}
public void Parse(string[] lines)
{
foreach (var line in lines)
{
if (line == string.Empty)
{
continue;
}
var splittedline = line.Split(new char[] { ' ' }, 2);
switch (splittedline[0])
{
case "v":
Vertices.Add(StringToPoint(splittedline[1]));
break;
case "vn":
Normals.Add(StringToVector(splittedline[1]));
break;
case "g":
LastGroupAdded = splittedline[1];
Groups.Add(LastGroupAdded, new Group());
break;
case "f":
Groups[LastGroupAdded].Add(
FanTriangulate(splittedline[1]));
break;
default: IgnoredLines++; break;
}
}
}
public void AddVertex(Vector3 pos, Vector3 normal, Vector2 texCoord)
{
Vertices.Add(pos);
Normals.Add(normal);
TexCoords.Add(texCoord);
Indices.Add(Indices.Count);
}
public void WriteToOBJ(TextWriter writer, int lodNumber, int firstVertexNumber, int firstNormalNumber, int firstCoordNumber,
Dictionary <string, int?> materialNames, Stream unknownData)
{
unknownData.Write(unknown);
unknownData.WriteByte(unknown2);
unknownData.WriteByte(unknown3);
double scaleFactor = ConvertScale(Scale);
writer.WriteLine($"g lod{lodNumber}/scale={scaleFactor}");
writer.WriteLine("# vertices");
Vertices.ForEach(vertex => vertex.WriteToOBJ(writer, scaleFactor));
writer.WriteLine("# normals");
Normals.ForEach(normal => normal.WriteToOBJ(writer));
List <UVCoordinate> coords = GetAllUVCoords();
writer.WriteLine("# UV coords");
coords.ForEach(coord => coord.WriteToOBJ(writer));
writer.WriteLine("# triangles");
Triangles.ForEach(polygon => polygon.WriteToOBJ(writer, false, Vertices, Normals, firstVertexNumber, firstNormalNumber, materialNames));
writer.WriteLine("# quads");
Quads.ForEach(polygon => polygon.WriteToOBJ(writer, true, Vertices, Normals, firstVertexNumber, firstNormalNumber, materialNames));
writer.WriteLine("# UV triangles");
UVTriangles.ForEach(polygon => polygon.WriteToOBJ(writer, false, Vertices, Normals, firstVertexNumber, firstNormalNumber, coords, firstCoordNumber, materialNames));
writer.WriteLine("# UV quads");
UVQuads.ForEach(polygon => polygon.WriteToOBJ(writer, true, Vertices, Normals, firstVertexNumber, firstNormalNumber, coords, firstCoordNumber, materialNames));
}
/// <summary>
/// Clears all data in this mesh.
/// </summary>
public void Clear()
{
Vertices.Clear();
Normals.Clear();
UVs.Clear();
Triangles.Clear();
}
public void NoLod()
{
var chunk = new Chunk(new[]
{
new V3d(0, 0, 0),
new V3d(1, 0, 0),
new V3d(1, 1, 0),
new V3d(0, 1, 0)
});
var config = ImportConfig.Default
.WithInMemoryStore()
.WithRandomKey()
.WithCreateOctreeLod(false)
;
var cloud = PointCloud.Chunks(chunk, config);
Assert.IsTrue(cloud.HasNormals == false);
Assert.IsTrue(cloud.HasLodNormals == false);
config = config
.WithRandomKey()
.WithEstimateNormals(ps => Normals.EstimateNormals((V3d[])ps, 5))
;
var cloud2 = cloud.GenerateNormals(config);
Assert.IsTrue(cloud2.HasNormals == true);
Assert.IsTrue(cloud2.Root.Value.Normals.Value.All(n => n == V3f.OOI));
Assert.IsTrue(cloud2.HasLodNormals == false);
}
public void Write(AssetWriter writer)
{
Vertices.Write(writer);
UV.Write(writer);
if (HasBindPoses(writer.Version))
{
BindPoses.Write(writer);
}
Normals.Write(writer);
Tangents.Write(writer);
Weights.Write(writer);
NormalSigns.Write(writer);
TangentSigns.Write(writer);
if (HasFloatColors(writer.Version))
{
FloatColors.Write(writer);
}
BoneIndices.Write(writer);
Triangles.Write(writer);
if (HasColors(writer.Version))
{
Colors.Write(writer);
}
if (HasUVInfo(writer.Version))
{
writer.Write(UVInfo);
}
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.Add(VerticesName, Vertices.ExportYAML(container));
node.Add(UVName, UV.ExportYAML(container));
if (HasBindPoses(container.ExportVersion))
{
node.Add(BindPosesName, BindPoses.ExportYAML(container));
}
node.Add(NormalsName, Normals.ExportYAML(container));
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(WeightsName, Weights.ExportYAML(container));
node.Add(NormalSignsName, NormalSigns.ExportYAML(container));
node.Add(TangentSignsName, TangentSigns.ExportYAML(container));
if (HasFloatColors(container.ExportVersion))
{
node.Add(FloatColorsName, FloatColors.ExportYAML(container));
}
node.Add(BoneIndicesName, BoneIndices.ExportYAML(container));
node.Add(TrianglesName, Triangles.ExportYAML(container));
if (HasColors(container.ExportVersion))
{
node.Add(ColorsName, Colors.ExportYAML(container));
}
if (HasUVInfo(container.ExportVersion))
{
node.Add(UVInfoName, UVInfo);
}
return(node);
}
public ObjFaceBuilder Vertex(int v, int?n = null, int?t = null)
{
Vertices.Add(v);
Normals.Add(n ?? -1);
UVs.Add(t ?? -1);
return(this);
}
/// <summary>
/// Clear Mesh
/// </summary>
public void Clear()
{
Positions.Clear();
Normals.Clear();
UVs.Clear();
Indices.Clear();
}
public void Read(AssetReader reader)
{
Vertices.Read(reader);
UV.Read(reader);
if (IsReadBindPoses(reader.Version))
{
BindPoses.Read(reader);
}
Normals.Read(reader);
Tangents.Read(reader);
Weight.Read(reader);
NormalSigns.Read(reader);
TangentSigns.Read(reader);
if (IsReadFloatColors(reader.Version))
{
FloatColors.Read(reader);
}
BoneIndices.Read(reader);
Triangles.Read(reader);
if (IsReadColors(reader.Version))
{
Colors.Read(reader);
}
if (IsReadUVInfo(reader.Version))
{
UVInfo = reader.ReadUInt32();
}
}
public void CreateDefaultNormals()
{
while (Normals.Count < Vertices.Count)
{
Normals.Add(new Vector3(0, 0, 1));
}
}
private void CreateRenderTargets(int width, int height)
{
Colors?.Dispose();
Albedo?.Dispose();
Normals?.Dispose();
Depth?.Dispose();
#if OPENGL
Colors = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.HalfVector4, DepthFormat.Depth24Stencil8);
Albedo = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.HalfVector4, DepthFormat.Depth24Stencil8);
Normals = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.HalfVector4, DepthFormat.Depth24Stencil8);
Depth = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Vector2, DepthFormat.Depth24Stencil8);
#else
Colors = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Rgba64, DepthFormat.Depth24Stencil8);
Albedo = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Rgba64, DepthFormat.Depth24Stencil8);
Normals = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Rgba64, DepthFormat.Depth24Stencil8);
Depth = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Vector2, DepthFormat.Depth24Stencil8);
#endif
_bufferTextureSize = new Vector2(width, height);
_gBufferTargets = new[] {
new RenderTargetBinding(Colors),
new RenderTargetBinding(Normals),
new RenderTargetBinding(Depth),
new RenderTargetBinding(Albedo)
};
_lightMap?.Dispose();
_lightMap = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
}
public string ToJson()
{
// I did think of using a JSON serialiser,
// either one of these two provided by the
// .NET framework or one of the other libraries:
// System.Runtime.Serialization.Json.DataContractJsonSerializer
// System.Web.Script.Serialization.JavaScriptSerializer
// However, reading this comparison and alternative
// implementation, I decided to just write the couple
// of lines myself.
// http://procbits.com/2011/08/11/fridaythe13th-the-best-json-parser-for-silverlight-and-net
string s = string.Format
("\n \"FacetCount\":{0},"
+ "\n \"VertexCount\":{1},"
+ "\n \"VertexCoords\":[{2}],"
+ "\n \"VertexIndices\":[{3}],"
+ "\n \"Normals\":[{4}],"
+ "\n \"NormalIndices\":[{5}],"
+ "\n \"Center\":[{6}],"
+ "\n \"Color\":[{7}],"
+ "\n \"Id\":\"{8}\"",
FacetCount,
VertexCount,
string.Join(",", VertexCoords.Select <int, string>(i => (_export_factor * i).ToString("0.#")).ToArray()),
string.Join(",", VertexIndices.Select <int, string>(i => i.ToString()).ToArray()),
string.Join(",", Normals.Select <double, string>(a => a.ToString("0.####")).ToArray()),
string.Join(",", NormalIndices.Select <int, string>(i => i.ToString())),
string.Join(",", Center.Select <int, string>(i => (_export_factor * i).ToString("0.#"))),
Color,
Id);
return("\n{" + s + "\n}");
}
} = 3; // по Z
/// <summary>
/// Добавляет коробку с заданными гранями, выровненными по заданным осям.
/// </summary>
/// <param name="c">Точка центра куба.</param>
/// <param name="Length">Длина коробки вдоль оси X.</param>
/// <param name="Width">Длина коробки вдоль оси Y.</param>
/// <param name="Height">Длина коробки вдоль оси Z.</param>
public override void Update()
{
//Очистка
Positions.Clear();
Indices.Clear();
Normals.Clear();
var c = new Vector3(Length, Width, Height) / 2;
AddCubeFace(c, Vector3.UnitX, Vector3.UnitZ, Length, Width, Height);
AddCubeFace(c, -Vector3.UnitX, Vector3.UnitZ, Length, Width, Height);
AddCubeFace(c, -Vector3.UnitY, Vector3.UnitZ, Width, Length, Height);
AddCubeFace(c, Vector3.UnitY, Vector3.UnitZ, Width, Length, Height);
AddCubeFace(c, Vector3.UnitZ, Vector3.UnitY, Height, Length, Width);
AddCubeFace(c, -Vector3.UnitZ, Vector3.UnitY, Height, Length, Width);
// добавление ребер
AddEdge(0, 1);
AddEdge(1, 2);
AddEdge(2, 3);
AddEdge(3, 0);
AddEdge(4, 5);
AddEdge(5, 6);
AddEdge(6, 7);
AddEdge(7, 4);
AddEdge(0, 5);
AddEdge(1, 4);
AddEdge(2, 7);
AddEdge(3, 6);
}
public void AddBlendShapesToMesh(Mesh mesh)
{
Dictionary <string, BlendShape> map = new Dictionary <string, BlendShape>();
foreach (var x in BlendShapes)
{
BlendShape bs = null;
if (!map.TryGetValue(x.Name, out bs))
{
bs = new BlendShape();
bs.Positions = Positions.ToArray();
bs.Normals = Normals.ToArray();
bs.Tangents = Tangents.Select(y => (Vector3)y).ToArray();
bs.Name = x.Name;
bs.FrameWeight = x.FrameWeight;
map.Add(x.Name, bs);
}
var j = x.VertexOffset;
for (int i = 0; i < x.Positions.Length; ++i, ++j)
{
bs.Positions[j] = x.Positions[i];
bs.Normals[j] = x.Normals[i];
bs.Tangents[j] = x.Tangents[i];
}
}
foreach (var kv in map)
{
//Debug.LogFormat("AddBlendShapeFrame: {0}", kv.Key);
mesh.AddBlendShapeFrame(kv.Key, kv.Value.FrameWeight,
kv.Value.Positions, kv.Value.Normals, kv.Value.Tangents);
}
}
public virtual void Clear()
{
Vertices.Clear();
Normals.Clear();
Colors.Clear();
Lighting.Clear();
Indexes.Clear();
}
/// <summary>
/// Get normals for this object
/// </summary>
/// <returns>normals for object</returns>
public Vector3[] GetNormals()
{
if (_recalculateNormals)
{
CalculateNormals();
}
return(Normals.ToArray());
}
public void ResetCurrent()
{
CurrentPosition = Normals.GetEnumerator();
CurrentPosition.MoveNext();
Current = CurrentPosition.Current;
}
public void Clear()
{
Vertices.Clear();
UVs.Clear();
Indices.Clear();
Normals.Clear();
Colours.Clear();
}
private void ReadNormal(string[] items)
{
var x = double.Parse(items[1]);
var y = double.Parse(items[2]);
var z = double.Parse(items[3]);
Normals.Add(Helper.CreatePoint(x, y, z));
}
/// <summary>
/// Add OBJ model
/// </summary>
/// <param name="Path"></param>
/// <returns></returns>
public Mesh AddOBJ(string Path)
{
FileStream fileStream = new FileStream(Path, FileMode.Open);
using (StreamReader reader = new StreamReader(fileStream))
{
string line;
Mesh tmp = new Mesh();
while ((line = reader.ReadLine()) != null)
{
string[] d = line.Split(" ");
//Vertex
if (d.Length == 4 && d[0].Equals("v"))
{
tmp.Positions.Add(new Vector3(float.Parse(d[1], NumberStyles.Any, CultureInfo.InvariantCulture), float.Parse(d[2], NumberStyles.Any, CultureInfo.InvariantCulture), float.Parse(d[3], NumberStyles.Any, CultureInfo.InvariantCulture)));
}
//UV
if (d.Length == 3 && d[0].Equals("vt"))
{
tmp.UVs.Add(new Vector2(float.Parse(d[1], NumberStyles.Any, CultureInfo.InvariantCulture), float.Parse(d[2], NumberStyles.Any, CultureInfo.InvariantCulture)));
}
//Normal
if (d.Length == 4 && d[0].Equals("vn"))
{
tmp.Normals.Add(new Vector3(float.Parse(d[1], NumberStyles.Any, CultureInfo.InvariantCulture), float.Parse(d[2], NumberStyles.Any, CultureInfo.InvariantCulture), float.Parse(d[3], NumberStyles.Any, CultureInfo.InvariantCulture)));
}
//Face
if (d.Length == 4 && d[0].Equals("f"))
{
string[] tri1 = d[1].Split("/");
string[] tri2 = d[2].Split("/");
string[] tri3 = d[3].Split("/");
Positions.Add(tmp.Positions[int.Parse(tri1[0]) - 1]);
Positions.Add(tmp.Positions[int.Parse(tri2[0]) - 1]);
Positions.Add(tmp.Positions[int.Parse(tri3[0]) - 1]);
UVs.Add(tmp.UVs[int.Parse(tri1[1]) - 1]);
UVs.Add(tmp.UVs[int.Parse(tri2[1]) - 1]);
UVs.Add(tmp.UVs[int.Parse(tri3[1]) - 1]);
Normals.Add(tmp.Normals[int.Parse(tri1[2]) - 1]);
Normals.Add(tmp.Normals[int.Parse(tri2[2]) - 1]);
Normals.Add(tmp.Normals[int.Parse(tri3[2]) - 1]);
for (int i = 0; i < 3; i++)
{
Indices.Add(Indices.Count);
}
}
}
}
return(this);
}
public Primitive(int vtxCount)
{
VertexCount = vtxCount;
Matrices.AddRange(new int[vtxCount]);
Positions.AddRange(new int[vtxCount]);
Normals.AddRange(new int[vtxCount]);
Colors.AddRange(new int[vtxCount]);
TexCoords.AddRange(new int[vtxCount]);
}
public string GetMetrics()
{
StringBuilder builder = new StringBuilder();
builder.Append($"Name = {Name}, ");
builder.Append($"Point Count = {Points.Count:N0}, ");
builder.Append($"Non-Zero Normals = {Normals.Count(n => n.X != 0.0f && n.Y != 0.0f && n.Z != 0.0f):N0}");
return(builder.ToString());
}
public void AddVtx(Primitive src, int vtxIdx)
{
VertexCount++;
Matrices.Add(src.Matrices[vtxIdx]);
Positions.Add(src.Positions[vtxIdx]);
Normals.Add(src.Normals[vtxIdx]);
Colors.Add(src.Colors[vtxIdx]);
TexCoords.Add(src.TexCoords[vtxIdx]);
}
public ObjFileParser()
{
// Dummies to get 1-indexed arrays.
Vertices.Add(Tuple.Point(0, 0, 0));
Normals.Add(Tuple.Vector(0, 0, 0));
// Add the default group
_groups.Add("", new Group());
}
public void Dispose()
{
Vertexes.Dispose();
FaceIndexes.Dispose();
TriangleOrder.Dispose();
Normals.Dispose();
Tangents.Dispose();
Uvs.Dispose();
}
