669 lines
20 KiB
C#
669 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
using RobloxFiles;
|
|
using RobloxFiles.DataTypes;
|
|
|
|
namespace BevelGenerator
|
|
{
|
|
public class Bone : Instance
|
|
{
|
|
public int NameIndex;
|
|
|
|
public short Id;
|
|
public short ParentId;
|
|
|
|
public float Unknown;
|
|
public CFrame CFrame;
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"[Bone: {Name}]";
|
|
}
|
|
}
|
|
|
|
public class Vertex
|
|
{
|
|
public Vector3 Position;
|
|
public Vector3 Normal;
|
|
public Vector3 UV;
|
|
|
|
public Color? Color;
|
|
public BoneWeights? Weights;
|
|
}
|
|
|
|
public class SkinData
|
|
{
|
|
public int FacesBegin;
|
|
public int FacesLength;
|
|
|
|
public int VertsBegin;
|
|
public int VertsLength;
|
|
|
|
public int NumBones;
|
|
public short[] BoneIndexTree;
|
|
}
|
|
|
|
public struct BoneWeights
|
|
{
|
|
public byte[] Bones;
|
|
public byte[] Weights;
|
|
|
|
public override string ToString()
|
|
{
|
|
var bones = string.Join(", ", Bones);
|
|
var weights = string.Join(", ", Weights);
|
|
|
|
return $"{{Bones: [{bones}] | Weights: [{weights}]}}";
|
|
}
|
|
}
|
|
|
|
public class Mesh
|
|
{
|
|
public int Version;
|
|
public ushort NumMeshes = 0;
|
|
|
|
public int NumVerts = 0;
|
|
public List<Vertex> Verts;
|
|
|
|
public int NumFaces = 0;
|
|
public List<int[]> Faces;
|
|
|
|
public ushort NumLODs;
|
|
public List<int> LODs;
|
|
|
|
public int NumBones = 0;
|
|
public List<Bone> Bones;
|
|
|
|
public int NumSkinData = 0;
|
|
public List<SkinData> SkinData;
|
|
|
|
public int NameTableSize = 0;
|
|
public byte[] NameTable;
|
|
|
|
public bool HasLODs => (Version >= 3);
|
|
public bool HasSkinning => (Version >= 4);
|
|
public bool HasVertexColors { get; private set; }
|
|
|
|
private static Vector3 ReadVector3(BinaryReader reader)
|
|
{
|
|
float x = reader.ReadSingle(),
|
|
y = reader.ReadSingle(),
|
|
z = reader.ReadSingle();
|
|
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
private static void LoadGeometry_Ascii(StringReader reader, Mesh mesh)
|
|
{
|
|
string header = reader.ReadLine();
|
|
mesh.NumMeshes = 1;
|
|
|
|
if (!header.StartsWith("version 1"))
|
|
throw new Exception("Expected version 1 header, got: " + header);
|
|
|
|
string version = header.Substring(8);
|
|
float vertScale = (version == "1.00" ? 0.5f : 1);
|
|
|
|
if (int.TryParse(reader.ReadLine(), out mesh.NumFaces))
|
|
mesh.NumVerts = mesh.NumFaces * 3;
|
|
else
|
|
throw new Exception("Expected 2nd line to be the polygon count.");
|
|
|
|
mesh.Faces = new List<int[]>();
|
|
mesh.Verts = new List<Vertex>();
|
|
|
|
string polyBuffer = reader.ReadLine();
|
|
MatchCollection matches = Regex.Matches(polyBuffer, @"\[(.*?)\]");
|
|
|
|
int face = 0;
|
|
int index = 0;
|
|
int target = 0;
|
|
|
|
var vertex = new Vertex();
|
|
|
|
foreach (Match m in matches)
|
|
{
|
|
string vectorStr = m.Groups[1].ToString();
|
|
|
|
float[] coords = vectorStr.Split(',')
|
|
.Select(coord => Format.ParseFloat(coord))
|
|
.ToArray();
|
|
|
|
if (target == 0)
|
|
vertex.Position = new Vector3(coords) * vertScale;
|
|
else if (target == 1)
|
|
vertex.Normal = new Vector3(coords);
|
|
else if (target == 2)
|
|
vertex.UV = new Vector3(coords[0], 1 - coords[1], 0);
|
|
|
|
target = (target + 1) % 3;
|
|
|
|
if (target == 0)
|
|
{
|
|
mesh.Verts.Add(vertex);
|
|
vertex = new Vertex();
|
|
|
|
if (index % 3 == 0)
|
|
{
|
|
int v = face * 3;
|
|
int[] faceDef = new int[3] { v, v + 1, v + 2 };
|
|
mesh.Faces.Add(faceDef);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void LoadGeometry_Binary(BinaryReader reader, Mesh mesh)
|
|
{
|
|
byte[] binVersion = reader.ReadBytes(13); // version x.xx\n
|
|
var headerSize = reader.ReadUInt16();
|
|
|
|
if (mesh.HasSkinning)
|
|
{
|
|
mesh.NumMeshes = reader.ReadUInt16();
|
|
|
|
mesh.NumVerts = reader.ReadInt32();
|
|
mesh.NumFaces = reader.ReadInt32();
|
|
|
|
mesh.NumLODs = reader.ReadUInt16();
|
|
mesh.NumBones = reader.ReadUInt16();
|
|
|
|
mesh.NameTableSize = reader.ReadInt32();
|
|
mesh.NumSkinData = reader.ReadInt32();
|
|
}
|
|
else
|
|
{
|
|
var sizeof_Vertex = reader.ReadByte();
|
|
mesh.HasVertexColors = (sizeof_Vertex > 36);
|
|
|
|
_ = reader.ReadByte();
|
|
|
|
if (mesh.HasLODs)
|
|
{
|
|
_ = reader.ReadUInt16();
|
|
mesh.NumLODs = reader.ReadUInt16();
|
|
}
|
|
|
|
if (mesh.NumLODs > 0)
|
|
mesh.NumMeshes = (ushort)(mesh.NumLODs - 1);
|
|
else
|
|
mesh.NumMeshes = 1;
|
|
|
|
mesh.NumVerts = reader.ReadInt32();
|
|
mesh.NumFaces = reader.ReadInt32();
|
|
|
|
mesh.NameTable = new byte[0];
|
|
}
|
|
|
|
mesh.LODs = new List<int>();
|
|
mesh.Bones = new List<Bone>();
|
|
mesh.Faces = new List<int[]>();
|
|
mesh.Verts = new List<Vertex>();
|
|
mesh.SkinData = new List<SkinData>();
|
|
|
|
// Read Vertices
|
|
for (int i = 0; i < mesh.NumVerts; i++)
|
|
{
|
|
var vert = new Vertex()
|
|
{
|
|
Position = ReadVector3(reader),
|
|
Normal = ReadVector3(reader),
|
|
UV = ReadVector3(reader)
|
|
};
|
|
|
|
Color? color = null;
|
|
|
|
if (mesh.HasVertexColors)
|
|
{
|
|
int rgba = reader.ReadInt32();
|
|
color = Color.FromArgb(rgba << 24 | rgba >> 8);
|
|
}
|
|
|
|
vert.Color = color;
|
|
mesh.Verts.Add(vert);
|
|
}
|
|
|
|
if (mesh.HasSkinning)
|
|
{
|
|
// Read Bone Weights?
|
|
for (int i = 0; i < mesh.NumVerts; i++)
|
|
{
|
|
var vert = mesh.Verts[i];
|
|
|
|
var weights = new BoneWeights()
|
|
{
|
|
Bones = reader.ReadBytes(4),
|
|
Weights = reader.ReadBytes(4)
|
|
};
|
|
|
|
vert.Weights = weights;
|
|
}
|
|
}
|
|
|
|
// Read Faces
|
|
for (int i = 0; i < mesh.NumFaces; i++)
|
|
{
|
|
int[] face = new int[3];
|
|
|
|
for (int f = 0; f < 3; f++)
|
|
face[f] = reader.ReadInt32();
|
|
|
|
mesh.Faces.Add(face);
|
|
}
|
|
|
|
if (mesh.HasLODs && mesh.NumLODs > 0)
|
|
{
|
|
// Read LOD ranges
|
|
for (int i = 0; i < mesh.NumLODs; i++)
|
|
{
|
|
int lod = reader.ReadInt32();
|
|
mesh.LODs.Add(lod);
|
|
}
|
|
}
|
|
|
|
if (mesh.HasSkinning)
|
|
{
|
|
// Read Bones
|
|
for (int i = 0; i < mesh.NumBones; i++)
|
|
{
|
|
float[] cf = new float[12];
|
|
|
|
Bone bone = new Bone()
|
|
{
|
|
NameIndex = reader.ReadInt32(),
|
|
Id = reader.ReadInt16(),
|
|
|
|
ParentId = reader.ReadInt16(),
|
|
Unknown = reader.ReadSingle()
|
|
};
|
|
|
|
for (int m = 0; m < 12; m++)
|
|
{
|
|
int index = (m + 3) % 12;
|
|
cf[index] = reader.ReadSingle();
|
|
}
|
|
|
|
bone.CFrame = new CFrame(cf);
|
|
mesh.Bones.Add(bone);
|
|
}
|
|
|
|
// Read Bone Names & Parents
|
|
var nameTable = reader.ReadBytes(mesh.NameTableSize);
|
|
mesh.NameTable = nameTable;
|
|
|
|
foreach (Bone bone in mesh.Bones)
|
|
{
|
|
int index = bone.NameIndex;
|
|
int parentId = bone.ParentId;
|
|
|
|
var buffer = new List<byte>();
|
|
|
|
while (true)
|
|
{
|
|
byte next = nameTable[index];
|
|
|
|
if (next > 0)
|
|
index++;
|
|
else
|
|
break;
|
|
|
|
buffer.Add(next);
|
|
}
|
|
|
|
var result = buffer.ToArray();
|
|
bone.Name = Encoding.UTF8.GetString(result);
|
|
|
|
if (parentId >= 0)
|
|
{
|
|
var parent = mesh.Bones[parentId];
|
|
bone.Parent = parent;
|
|
}
|
|
}
|
|
|
|
// Read Skin Data?
|
|
for (int p = 0; p < mesh.NumSkinData; p++)
|
|
{
|
|
var skinData = new SkinData()
|
|
{
|
|
FacesBegin = reader.ReadInt32(),
|
|
FacesLength = reader.ReadInt32(),
|
|
|
|
VertsBegin = reader.ReadInt32(),
|
|
VertsLength = reader.ReadInt32(),
|
|
|
|
NumBones = reader.ReadInt32(),
|
|
BoneIndexTree = new short[26]
|
|
};
|
|
|
|
for (int i = 0; i < 26; i++)
|
|
skinData.BoneIndexTree[i] = reader.ReadInt16();
|
|
|
|
mesh.SkinData.Add(skinData);
|
|
}
|
|
}
|
|
|
|
|
|
Debugger.Break();
|
|
}
|
|
|
|
public void AddLOD(Mesh lodMesh)
|
|
{
|
|
Verts.AddRange(lodMesh.Verts);
|
|
|
|
Faces.AddRange
|
|
(
|
|
lodMesh.Faces.Select
|
|
(
|
|
face => face
|
|
.Select(i => i + NumVerts)
|
|
.ToArray()
|
|
)
|
|
);
|
|
|
|
NumVerts = Verts.Count;
|
|
NumFaces = Faces.Count;
|
|
|
|
LODs.Add(NumFaces);
|
|
NumLODs += 1;
|
|
}
|
|
|
|
public void SaveV1(Stream stream)
|
|
{
|
|
using (StringWriter writer = new StringWriter())
|
|
{
|
|
writer.WriteLine("version 1.00");
|
|
writer.WriteLine(NumFaces);
|
|
|
|
for (int i = 0; i < NumFaces; i++)
|
|
{
|
|
var face = Faces[i];
|
|
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
var vert = Verts[face[j]];
|
|
|
|
writer.Write('[');
|
|
writer.Write(vert.Position * 2f);
|
|
|
|
writer.Write("][");
|
|
writer.Write(vert.Normal);
|
|
|
|
writer.Write("][");
|
|
writer.Write(vert.UV.X);
|
|
|
|
writer.Write(", ");
|
|
writer.Write(vert.UV.Y);
|
|
|
|
writer.Write(", 0]");
|
|
}
|
|
}
|
|
|
|
using (BinaryWriter bin = new BinaryWriter(stream))
|
|
{
|
|
string file = writer.ToString();
|
|
byte[] mesh = Encoding.ASCII.GetBytes(file);
|
|
stream.Write(mesh, 0, mesh.Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Save(Stream stream)
|
|
{
|
|
const ushort HeaderSize = 16;
|
|
const byte VertSize = 40;
|
|
const byte FaceSize = 12;
|
|
const ushort LOD_Size = 4;
|
|
|
|
byte[] VersionHeader = Encoding.UTF8.GetBytes("version 3.00\n");
|
|
|
|
if (NumLODs == 0)
|
|
{
|
|
NumLODs = 2;
|
|
LODs = new List<int> { 0, NumFaces };
|
|
}
|
|
|
|
using (BinaryWriter writer = new BinaryWriter(stream))
|
|
{
|
|
writer.Write(VersionHeader);
|
|
writer.Write(HeaderSize);
|
|
|
|
writer.Write(VertSize);
|
|
writer.Write(FaceSize);
|
|
writer.Write(LOD_Size);
|
|
|
|
writer.Write(NumLODs);
|
|
writer.Write(NumVerts);
|
|
writer.Write(NumFaces);
|
|
|
|
for (int i = 0; i < NumVerts; i++)
|
|
{
|
|
Vertex vertex = Verts[i];
|
|
|
|
Vector3 pos = vertex.Position;
|
|
writer.Write(pos.X);
|
|
writer.Write(pos.Y);
|
|
writer.Write(pos.Z);
|
|
|
|
Vector3 norm = vertex.Normal;
|
|
writer.Write(norm.X);
|
|
writer.Write(norm.Y);
|
|
writer.Write(norm.Z);
|
|
|
|
Vector3 uv = vertex.UV;
|
|
writer.Write(uv.X);
|
|
writer.Write(uv.Y);
|
|
writer.Write(uv.Z);
|
|
|
|
if (vertex.Color.HasValue)
|
|
{
|
|
var color = vertex.Color.Value;
|
|
int argb = color.ToArgb();
|
|
|
|
int rgba = (argb << 8 | argb >> 24);
|
|
writer.Write(rgba);
|
|
}
|
|
else
|
|
{
|
|
writer.Write(-1);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < NumFaces; i++)
|
|
{
|
|
int[] faces = Faces[i];
|
|
|
|
for (int f = 0; f < 3; f++)
|
|
{
|
|
int face = faces[f];
|
|
writer.Write(face);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < NumLODs; i++)
|
|
{
|
|
int lod = LODs[i];
|
|
writer.Write(lod);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Mesh FromObjFile(string filePath)
|
|
{
|
|
string contents = File.ReadAllText(filePath);
|
|
|
|
Mesh mesh = new Mesh()
|
|
{
|
|
Version = 3,
|
|
Faces = new List<int[]>(),
|
|
Verts = new List<Vertex>()
|
|
};
|
|
|
|
var uvTable = new List<Vector3>();
|
|
var posTable = new List<Vector3>();
|
|
var normTable = new List<Vector3>();
|
|
|
|
var vertexLookup = new Dictionary<string, int>();
|
|
|
|
using (StringReader reader = new StringReader(contents))
|
|
{
|
|
string line;
|
|
|
|
while ((line = reader.ReadLine()) != null)
|
|
{
|
|
if (line.Length == 0)
|
|
continue;
|
|
|
|
string[] buffer = line.Split(' ');
|
|
string action = buffer[0];
|
|
|
|
switch (action)
|
|
{
|
|
case "v":
|
|
case "vn":
|
|
case "vt":
|
|
{
|
|
float[] input = buffer
|
|
.Skip(1)
|
|
.Where(str => !string.IsNullOrEmpty(str))
|
|
.Select(float.Parse)
|
|
.ToArray();
|
|
|
|
var value = new Vector3(input);
|
|
List<Vector3> target = null;
|
|
|
|
switch (action)
|
|
{
|
|
case "v":
|
|
{
|
|
target = posTable;
|
|
break;
|
|
}
|
|
case "vn":
|
|
{
|
|
target = normTable;
|
|
break;
|
|
}
|
|
case "vt":
|
|
{
|
|
target = uvTable;
|
|
break;
|
|
}
|
|
}
|
|
|
|
target.Add(value);
|
|
break;
|
|
}
|
|
case "f":
|
|
{
|
|
int[] face = new int[3];
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
string faceDef = buffer[i + 1];
|
|
string[] indices = faceDef.Split('/');
|
|
|
|
int uvId = int.Parse(indices[1]) - 1;
|
|
int posId = int.Parse(indices[0]) - 1;
|
|
int normId = int.Parse(indices[2]) - 1;
|
|
|
|
string key = $"{posId}/{uvId}/{normId}";
|
|
|
|
if (!vertexLookup.ContainsKey(key))
|
|
{
|
|
int faceId = mesh.NumVerts++;
|
|
vertexLookup.Add(key, faceId);
|
|
|
|
Vertex vert = new Vertex()
|
|
{
|
|
Position = posTable[posId],
|
|
Normal = normTable[normId],
|
|
UV = uvTable[uvId]
|
|
};
|
|
|
|
mesh.Verts.Add(vert);
|
|
}
|
|
|
|
face[i] = vertexLookup[key];
|
|
}
|
|
|
|
mesh.Faces.Add(face);
|
|
mesh.NumFaces++;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return mesh;
|
|
}
|
|
|
|
public static Mesh FromBuffer(byte[] data)
|
|
{
|
|
string file = Encoding.ASCII.GetString(data);
|
|
|
|
if (!file.StartsWith("version "))
|
|
throw new Exception("Invalid .mesh header!");
|
|
|
|
string versionStr = file.Substring(8, 4);
|
|
double version = Format.ParseDouble(versionStr);
|
|
|
|
Mesh mesh = new Mesh();
|
|
mesh.Version = (int)version;
|
|
|
|
IDisposable disposeThis;
|
|
|
|
if (mesh.Version == 1)
|
|
{
|
|
StringReader buffer = new StringReader(file);
|
|
LoadGeometry_Ascii(buffer, mesh);
|
|
|
|
disposeThis = buffer;
|
|
}
|
|
else
|
|
{
|
|
MemoryStream stream = new MemoryStream(data);
|
|
|
|
using (BinaryReader reader = new BinaryReader(stream))
|
|
LoadGeometry_Binary(reader, mesh);
|
|
|
|
disposeThis = stream;
|
|
}
|
|
|
|
disposeThis.Dispose();
|
|
disposeThis = null;
|
|
|
|
return mesh;
|
|
}
|
|
|
|
public static Mesh FromStream(Stream stream)
|
|
{
|
|
byte[] data;
|
|
|
|
using (MemoryStream buffer = new MemoryStream())
|
|
{
|
|
stream.CopyTo(buffer);
|
|
data = buffer.ToArray();
|
|
}
|
|
|
|
return FromBuffer(data);
|
|
}
|
|
|
|
public static Mesh FromFile(string path)
|
|
{
|
|
Mesh result;
|
|
|
|
using (FileStream meshStream = File.OpenRead(path))
|
|
result = FromStream(meshStream);
|
|
|
|
return result;
|
|
}
|
|
}
|
|
} |