private void ReadHeader(Stream s)
{
MeshHeader h = new MeshHeader();
h.MinPosition = new Vector3(Helpers.ReadFloat(s), Helpers.ReadFloat(s), Helpers.ReadFloat(s));
h.Unknown01 = Helpers.ReadFloat(s);
h.MaxPosition = new Vector3(Helpers.ReadFloat(s), Helpers.ReadFloat(s), Helpers.ReadFloat(s));
h.Unknown02 = Helpers.ReadFloat(s);
h.LODoffsets = new long[6];
for (int i = 0; i < 6; i++)
{
h.LODoffsets[i] = Helpers.ReadLong(s);
}
h.MeshPath = SerializeString(s);
h.MeshName = SerializeString(s);
h.Unknown03 = Helpers.ReadInt(s);
h.Unknown04 = Helpers.ReadInt(s);
h.Unknown05 = Helpers.ReadInt(s);
h.TotalLODCount = Helpers.ReadShort(s);
h.TotalSubObjectCount = Helpers.ReadShort(s);
h.LODs = new List <MeshLOD>();
for (int i = 0; i < 6; i++)
{
if (h.LODoffsets[i] != 0)
{
s.Seek(h.LODoffsets[i], 0);
h.LODs.Add(ReadMeshLOD(s));
}
}
header = h;
}
private int[] readDTris(ByteBuffer buf, MeshHeader header)
{
int[] tris = new int[4 * header.detailTriCount];
for (int i = 0; i < tris.Length; i++)
{
tris[i] = buf.get() & 0xFF;
}
return(tris);
}
static MeshHeader WriterHeader(this MeshAsset mesh, BinaryWriter sw)
{
MeshHeader header = new MeshHeader();
header.Signature = FourCC.Value('M', 'E', 'S', 'H');
header.Machine = 0;
header.NumberOfSections = 1;
header.SizeOfOptional = 0;
sw.Write(header.Signature);
sw.Write(header.Machine);
sw.Write(header.NumberOfSections);
sw.Write(header.SizeOfOptional);
return(header);
}
private PolyDetail[] readPolyDetails(ByteBuffer buf, MeshHeader header, bool cCompatibility)
{
PolyDetail[] polys = new PolyDetail[header.detailMeshCount];
for (int i = 0; i < polys.Length; i++)
{
polys[i] = new PolyDetail();
polys[i].vertBase = buf.Int;
polys[i].triBase = buf.Int;
polys[i].vertCount = buf.get() & 0xFF;
polys[i].triCount = buf.get() & 0xFF;
if (cCompatibility)
{
buf.Short; // C struct padding
}
}
return(polys);
}
private OffMeshConnection[] readOffMeshCons(ByteBuffer buf, MeshHeader header)
{
OffMeshConnection[] cons = new OffMeshConnection[header.offMeshConCount];
for (int i = 0; i < cons.Length; i++)
{
cons[i] = new OffMeshConnection();
for (int j = 0; j < 6; j++)
{
cons[i].pos[j] = buf.Float;
}
cons[i].rad = buf.Float;
cons[i].poly = buf.Short & 0xFFFF;
cons[i].flags = buf.get() & 0xFF;
cons[i].side = buf.get() & 0xFF;
cons[i].userId = buf.Int;
}
return(cons);
}
private BVNode[] readBVTree(ByteBuffer buf, MeshHeader header)
{
BVNode[] nodes = new BVNode[header.bvNodeCount];
for (int i = 0; i < nodes.Length; i++)
{
nodes[i] = new BVNode();
for (int j = 0; j < 3; j++)
{
nodes[i].bmin[j] = buf.Short & 0xFFFF;
}
for (int j = 0; j < 3; j++)
{
nodes[i].bmax[j] = buf.Short & 0xFFFF;
}
nodes[i].i = buf.Int;
}
return(nodes);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void write(java.io.OutputStream stream, org.recast4j.detour.MeshData data, java.nio.ByteOrder order, boolean cCompatibility) throws java.io.IOException
public virtual void write(System.IO.Stream stream, MeshData data, ByteOrder order, bool cCompatibility)
{
MeshHeader header = data.header;
write(stream, header.magic, order);
write(stream, cCompatibility ? MeshHeader.DT_NAVMESH_VERSION : MeshHeader.DT_NAVMESH_VERSION_RECAST4J, order);
write(stream, header.x, order);
write(stream, header.y, order);
write(stream, header.layer, order);
write(stream, header.userId, order);
write(stream, header.polyCount, order);
write(stream, header.vertCount, order);
write(stream, header.maxLinkCount, order);
write(stream, header.detailMeshCount, order);
write(stream, header.detailVertCount, order);
write(stream, header.detailTriCount, order);
write(stream, header.bvNodeCount, order);
write(stream, header.offMeshConCount, order);
write(stream, header.offMeshBase, order);
write(stream, header.walkableHeight, order);
write(stream, header.walkableRadius, order);
write(stream, header.walkableClimb, order);
write(stream, header.bmin[0], order);
write(stream, header.bmin[1], order);
write(stream, header.bmin[2], order);
write(stream, header.bmax[0], order);
write(stream, header.bmax[1], order);
write(stream, header.bmax[2], order);
write(stream, header.bvQuantFactor, order);
writeVerts(stream, data.verts, header.vertCount, order);
writePolys(stream, data, order);
if (cCompatibility)
{
sbyte[] linkPlaceholder = new sbyte[header.maxLinkCount * MeshDataReader.getSizeofLink(false)];
stream.Write(linkPlaceholder, 0, linkPlaceholder.Length);
}
writePolyDetails(stream, data, order, cCompatibility);
writeVerts(stream, data.detailVerts, header.detailVertCount, order);
writeDTris(stream, data);
writeBVTree(stream, data, order);
writeOffMeshCons(stream, data, order);
}
private Poly[] readPolys(ByteBuffer buf, MeshHeader header, int maxVertPerPoly)
{
Poly[] polys = new Poly[header.polyCount];
for (int i = 0; i < polys.Length; i++)
{
polys[i] = new Poly(i, maxVertPerPoly);
polys[i].firstLink = buf.Int;
for (int j = 0; j < polys[i].verts.Length; j++)
{
polys[i].verts[j] = buf.Short & 0xFFFF;
}
for (int j = 0; j < polys[i].neis.Length; j++)
{
polys[i].neis[j] = buf.Short & 0xFFFF;
}
polys[i].flags = buf.Short & 0xFFFF;
polys[i].vertCount = buf.get() & 0xFF;
polys[i].areaAndtype = buf.get() & 0xFF;
}
return(polys);
}
protected MeshHeader ReadHeader(Stream ms)
{
var head = new MeshHeader();
var buffer = new byte[4];
ms.Read(buffer, 0, buffer.Length);
if (BitConverter.ToUInt32(buffer, 0) != MeshMagic)
{
throw new InvalidDataException("Wrong header magic");
}
ms.Read(buffer, 0, buffer.Length);
head.Platform = BitConverter.ToUInt32(buffer, 0);
ms.Read(buffer, 0, buffer.Length);
head.Version = BitConverter.ToUInt32(buffer, 0);
ms.Read(buffer, 0, buffer.Length);
head.FileSize = BitConverter.ToUInt32(buffer, 0);
var chkSumBuffer = new byte[16];
ms.Read(chkSumBuffer, 0, chkSumBuffer.Length);
head.Checksum = chkSumBuffer;
ms.Read(buffer, 0, buffer.Length);
head.HeaderOffset = BitConverter.ToUInt32(buffer, 0);
ms.Read(buffer, 0, buffer.Length);
head.HeaderSize = BitConverter.ToUInt32(buffer, 0);
ms.Read(buffer, 0, buffer.Length);
head.ContentOffset = BitConverter.ToUInt32(buffer, 0);
ms.Read(buffer, 0, buffer.Length);
head.ContentSize = BitConverter.ToUInt32(buffer, 0);
return(head);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: org.recast4j.detour.MeshData read(ByteBuffer buf, int maxVertPerPoly, boolean is32Bit) throws java.io.IOException
internal virtual MeshData read(ByteBuffer buf, int maxVertPerPoly, bool is32Bit)
{
MeshData data = new MeshData();
MeshHeader header = new MeshHeader();
data.header = header;
header.magic = buf.Int;
if (header.magic != MeshHeader.DT_NAVMESH_MAGIC)
{
header.magic = IOUtils.swapEndianness(header.magic);
if (header.magic != MeshHeader.DT_NAVMESH_MAGIC)
{
throw new IOException("Invalid magic");
}
buf.order(buf.order() == ByteOrder.BIG_ENDIAN ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
}
header.version = buf.Int;
if (header.version != MeshHeader.DT_NAVMESH_VERSION)
{
if (header.version != MeshHeader.DT_NAVMESH_VERSION_RECAST4J)
{
throw new IOException("Invalid version");
}
}
bool cCompatibility = header.version == MeshHeader.DT_NAVMESH_VERSION;
header.x = buf.Int;
header.y = buf.Int;
header.layer = buf.Int;
header.userId = buf.Int;
header.polyCount = buf.Int;
header.vertCount = buf.Int;
header.maxLinkCount = buf.Int;
header.detailMeshCount = buf.Int;
header.detailVertCount = buf.Int;
header.detailTriCount = buf.Int;
header.bvNodeCount = buf.Int;
header.offMeshConCount = buf.Int;
header.offMeshBase = buf.Int;
header.walkableHeight = buf.Float;
header.walkableRadius = buf.Float;
header.walkableClimb = buf.Float;
for (int j = 0; j < 3; j++)
{
header.bmin[j] = buf.Float;
}
for (int j = 0; j < 3; j++)
{
header.bmax[j] = buf.Float;
}
header.bvQuantFactor = buf.Float;
data.verts = readVerts(buf, header.vertCount);
data.polys = readPolys(buf, header, maxVertPerPoly);
if (cCompatibility)
{
buf.position(buf.position() + header.maxLinkCount * getSizeofLink(is32Bit));
}
data.detailMeshes = readPolyDetails(buf, header, cCompatibility);
data.detailVerts = readVerts(buf, header.detailVertCount);
data.detailTris = readDTris(buf, header);
data.bvTree = readBVTree(buf, header);
data.offMeshCons = readOffMeshCons(buf, header);
return(data);
}
public void Read(byte[] data)
{
int pos = 0;
// read the data header
CmpParser.ParseUInt32(data, ref pos); // MeshType
CmpParser.ParseUInt32(data, ref pos); // SurfaceType
this.MeshCount = CmpParser.ParseUInt16(data, ref pos);
this.NumRefVertices = CmpParser.ParseUInt16(data, ref pos);
this.FlexibleVertexFormat = (D3Dfvf)CmpParser.ParseUInt16(data, ref pos);
this.VertexCount = CmpParser.ParseUInt16(data, ref pos);
// the FVF defines what fields are included for each vertex
/*switch (FlexibleVertexFormat)
* {
* case D3DFVF.XYZ:
* case D3DFVF.XYZ | D3DFVF.NORMAL:
* case D3DFVF.XYZ | D3DFVF.TEX1:
* case D3DFVF.XYZ | D3DFVF.NORMAL | D3DFVF.TEX1:
* case D3DFVF.XYZ | D3DFVF.DIFFUSE | D3DFVF.TEX1:
* case D3DFVF.XYZ | D3DFVF.NORMAL | D3DFVF.DIFFUSE | D3DFVF.TEX1:
* case D3DFVF.XYZ | D3DFVF.NORMAL | D3DFVF.TEX2:
* case D3DFVF.XYZ | D3DFVF.NORMAL | D3DFVF.DIFFUSE | D3DFVF.TEX2:
* break;
* default:
* throw new Exception(string.Format("FVF 0x{0:X} not supported.", FlexibleVertexFormat));
* }*/
// read the mesh headers
int triangleStartOffset = 0;
this.Meshes = new MeshHeader[this.MeshCount];
for (int i = 0; i < this.MeshCount; ++i)
{
MeshHeader mesh = new MeshHeader();
CmpParser.ParseUInt32(data, ref pos); // MaterialId
mesh.StartVertex = CmpParser.ParseUInt16(data, ref pos);
mesh.EndVertex = CmpParser.ParseUInt16(data, ref pos);
mesh.NumRefVertices = CmpParser.ParseUInt16(data, ref pos);
CmpParser.ParseUInt16(data, ref pos); // Padding
mesh.TriangleStart = triangleStartOffset;
triangleStartOffset += mesh.NumRefVertices;
this.Meshes[i] = mesh;
}
// read the triangle data
int triangleCount = this.NumRefVertices / 3;
this.Triangles = new Triangle[triangleCount];
for (int i = 0; i < triangleCount; ++i)
{
Triangle triangle = new Triangle();
triangle.Vertex1 = CmpParser.ParseUInt16(data, ref pos);
triangle.Vertex3 = CmpParser.ParseUInt16(data, ref pos);
triangle.Vertex2 = CmpParser.ParseUInt16(data, ref pos);
this.Triangles[i] = triangle;
}
// read the vertex data
try
{
this.Vertices = new Vertex[this.VertexCount];
for (int i = 0; i < this.VertexCount; ++i)
{
Vertex vertex = new Vertex();
vertex.Fvf = this.FlexibleVertexFormat;
vertex.Position = CmpParser.ParsePoint3D(data, ref pos);
if ((this.FlexibleVertexFormat & D3Dfvf.Normal) == D3Dfvf.Normal)
{
vertex.Normal = CmpParser.ParseVector3D(data, ref pos);
}
if ((this.FlexibleVertexFormat & D3Dfvf.Diffuse) == D3Dfvf.Diffuse)
{
CmpParser.ParseUInt32(data, ref pos); // Diffuse
}
if ((this.FlexibleVertexFormat & D3Dfvf.Tex1) == D3Dfvf.Tex1)
{
CmpParser.ParseFloat(data, ref pos); // S
CmpParser.ParseFloat(data, ref pos); // T
}
if ((this.FlexibleVertexFormat & D3Dfvf.Tex2) == D3Dfvf.Tex2)
{
CmpParser.ParseFloat(data, ref pos); // S
CmpParser.ParseFloat(data, ref pos); // T
CmpParser.ParseFloat(data, ref pos); // U
CmpParser.ParseFloat(data, ref pos); // V
}
if ((this.FlexibleVertexFormat & D3Dfvf.Tex4) == D3Dfvf.Tex4)
{
CmpParser.ParseFloat(data, ref pos); // S
CmpParser.ParseFloat(data, ref pos); // T
CmpParser.ParseFloat(data, ref pos); // TangentX
CmpParser.ParseFloat(data, ref pos); // TangentY
CmpParser.ParseFloat(data, ref pos); // TangentZ
CmpParser.ParseFloat(data, ref pos); // BinormalX
CmpParser.ParseFloat(data, ref pos); // BinormalY
CmpParser.ParseFloat(data, ref pos); // BinormalZ
}
if ((this.FlexibleVertexFormat & D3Dfvf.Tex5) == D3Dfvf.Tex5)
{
CmpParser.ParseFloat(data, ref pos); // S
CmpParser.ParseFloat(data, ref pos); // T
CmpParser.ParseFloat(data, ref pos); // U
CmpParser.ParseFloat(data, ref pos); // V
CmpParser.ParseFloat(data, ref pos); // TangentX
CmpParser.ParseFloat(data, ref pos); // TangentY
CmpParser.ParseFloat(data, ref pos); // TangentZ
CmpParser.ParseFloat(data, ref pos); // BinormalX
CmpParser.ParseFloat(data, ref pos); // BinormalY
CmpParser.ParseFloat(data, ref pos); // BinormalZ
}
this.Vertices[i] = vertex;
}
}
catch
{
// MessageBox.Show("Header has more vertices then data", "Error");
}
}
public static async Task HandleIncomingConnections()
{
while (true)
{
// Will wait here until we hear from a connection
HttpListenerContext ctx = await listener.GetContextAsync();
// Peel out the requests and response objects
HttpListenerRequest req = ctx.Request;
HttpListenerResponse resp = ctx.Response;
byte[] data = { };
switch (req.Url.AbsolutePath)
{
case "/getvmf":
string[] files = Directory.GetFiles(@"D:\Downloads\INFRA vmf\", req.QueryString["q"], SearchOption.AllDirectories);
if (files.Length > 0)
{
data = File.ReadAllBytes(files[0]);
}
break;
case "/getmat":
string mat_dir = "materials/" + req.QueryString["q"] + ".vmt";
if (!File.Exists(gamefiles + mat_dir)) // check if this material even exists
{
Console.Write("material doesnt exist " + mat_dir);
data = Encoding.UTF8.GetBytes("bad material " + mat_dir);
break;
}
string matname = Path.GetFileNameWithoutExtension(mat_dir.Split("\\").Last());
string outfile = $"{matname}.png";
if (File.Exists(sourceImport + outfile)) // check if this material has already been extracted
{
data = Encoding.UTF8.GetBytes("rbxasset://sourceimport/" + outfile);
break;
}
vmt vmtdata = new vmt(gamefiles + mat_dir);
string png = vtf2png(vmtdata.basetexture);
if (File.Exists(png)) // if it doesn't exist lets send back an invalid asset anyways.
{
File.Copy(png, sourceImport + outfile, true);
}
data = Encoding.UTF8.GetBytes("rbxasset://sourceimport/" + outfile);
break;
case "/getmodel":
string mdl_dir = req.QueryString["q"];
if (!mdl_dir.StartsWith("models/") || !File.Exists(gamefiles + mdl_dir)) // check if this model even exists
{
data = Encoding.UTF8.GetBytes("bad model");
break;
}
string mdlname = Path.GetFileNameWithoutExtension(mdl_dir.Split("/").Last());
string outFileName = mdlname + ".mesh";
string outFile = sourceImport + outFileName;
if (!File.Exists(outFile)) // check if this model has already been extracted
{
Process.Start("Crowbar.exe", $"-p \"{gamefiles + mdl_dir}\" -o \"tmp\\{mdlname}\"");
}
while (!Directory.Exists($"tmp\\{mdlname}"))
{
Thread.Sleep(10);
}
WaitForExtract($"tmp\\{mdlname}\\{mdlname}.qc");
qc modelInfo = new qc(mdlname);
WaitForExtract($"tmp\\{mdlname}\\{modelInfo.smdFile}");
List <smdVert> verts = smd.GetSmdData($"tmp\\{mdlname}\\{modelInfo.smdFile}");
string probablythetexture = modelInfo.cdmaterials + modelInfo.texturegroup[0][0];
using (FileStream file = File.Open(outFile, FileMode.Create))
{
StreamWriter writer = new StreamWriter(file);
writer.WriteLine("version 2.00");
writer.Flush();
MeshHeader meshHeader = new MeshHeader();
meshHeader.sizeof_MeshHeader = (short)Marshal.SizeOf(typeof(MeshHeader));
meshHeader.sizeof_Vertex = (byte)Marshal.SizeOf(typeof(Vertex));
meshHeader.sizeof_Face = (byte)Marshal.SizeOf(typeof(Face));
meshHeader.numVerts = (uint)verts.Count;
meshHeader.numFaces = (uint)verts.Count / 3;
Write(file, meshHeader);
for (int i = 0; i < meshHeader.numVerts; i++)
{
Vertex vertex = new Vertex();
vertex.px = verts[i].PosX;
vertex.py = verts[i].PosY;
vertex.pz = verts[i].PosZ;
vertex.nx = verts[i].NormX;
vertex.ny = verts[i].NormY;
vertex.nz = verts[i].NormZ;
vertex.tu = verts[i].U;
vertex.tv = 1 - verts[i].V;
vertex.tw = 0;
vertex.r = 255;
vertex.g = 255;
vertex.b = 255;
vertex.a = 255;
Write(file, vertex);
}
for (uint i = 0; i < meshHeader.numFaces; i++)
{
Face face = new Face();
face.a = i * 3 + 0;
face.b = i * 3 + 1;
face.c = i * 3 + 2;
Write(file, face);
}
writer.Close();
}
data = Encoding.UTF8.GetBytes("rbxasset://sourceimport/" + outFileName + "|" + probablythetexture);
Console.WriteLine("Exported.");
break;
}
// Write the response info
resp.ContentType = "text/html";
resp.ContentEncoding = Encoding.UTF8;
resp.ContentLength64 = data.LongLength;
// Write out to the response stream (asynchronously), then close it
await resp.OutputStream.WriteAsync(data, 0, data.Length);
resp.Close();
}
}
private void ReadHeader(Stream s)
{
MeshHeader h = new MeshHeader();
h.MinPosition = new Vector3(Helpers.ReadFloat(s), Helpers.ReadFloat(s), Helpers.ReadFloat(s));
h.Unknown01 = Helpers.ReadFloat(s);
h.MaxPosition = new Vector3(Helpers.ReadFloat(s), Helpers.ReadFloat(s), Helpers.ReadFloat(s));
h.Unknown02 = Helpers.ReadFloat(s);
h.LODoffsets = new long[6];
for (int i = 0; i < 6; i++)
h.LODoffsets[i] = Helpers.ReadLong(s);
h.MeshPath = SerializeString(s);
h.MeshName = SerializeString(s);
h.Unknown03 = Helpers.ReadInt(s);
h.Unknown04 = Helpers.ReadInt(s);
h.Unknown05 = Helpers.ReadInt(s);
h.TotalLODCount = Helpers.ReadShort(s);
h.TotalSubObjectCount = Helpers.ReadShort(s);
h.LODs = new List<MeshLOD>();
for (int i = 0; i < 6; i++)
if (h.LODoffsets[i] != 0)
{
s.Seek(h.LODoffsets[i], 0);
h.LODs.Add(ReadMeshLOD(s));
}
header = h;
}
public Mesh(MeshHeader header, BinaryReader reader)
{
Header = header;
var start = reader.BaseStream.Position;
}
