private static void ExportExtraMaterials(uint tex, WoWFormatLib.Structs.WMO.WMO wmo, List <Structs.Material> mats, int matIdx, string path)
{
Stream ms = null;
if (CASC.FileExists(tex))
{
var mat = new Structs.Material();
if (wmo.textures == null)
{
if (Listfile.TryGetFilename(tex, out var textureFilename))
{
mat.filename = Path.GetFileNameWithoutExtension(textureFilename).Replace(" ", "");
}
else
{
mat.filename = tex.ToString();
}
ms = CASC.OpenFile(tex);
}
else
{
for (var ti = 0; ti < wmo.textures.Count(); ti++)
{
if (wmo.textures[ti].startOffset == tex)
{
mat.filename = Path.GetFileNameWithoutExtension(wmo.textures[ti].filename).Replace(" ", "");
ms = CASC.OpenFile(wmo.textures[ti].filename);
}
}
}
if (ms == null)
{
return; // Can this even happen?
}
string saveLocation = Path.Combine(path, mat.filename + ".png");
if (!File.Exists(saveLocation))
{
try
{
using (BlpFile blp = new BlpFile(ms))
blp.GetBitmap(0).Save(saveLocation);
}
catch (Exception e)
{
CASCLib.Logger.WriteLine("Exception while saving BLP " + mat.filename + ": " + e.Message);
}
}
mats.Add(mat);
}
}
public void Compile(string wmoname)
{
WMOReader wmoreader = new WMOReader();
wmoreader.LoadWMO(wmoname);
WoWFormatLib.Structs.WMO.WMO wmo = wmoreader.wmofile;
Console.WriteLine(wmoname);
if (wmo.group.Count() == 0)
{
Console.WriteLine("WMO " + wmoname + " has no groups! Skipping..");
return;
}
int wmo_minx = 999999999;
int wmo_maxx = 0;
int wmo_miny = 999999999;
int wmo_maxy = 0;
int numtiles = 0;
//Determine min max offset
for (int i = 0; i < wmo.group.Count(); i++)
{
string groupid = i.ToString().PadLeft(3, '0');
double drawx1 = wmo.groupInfo[i].boundingBox1.X * 2;
double drawy1 = wmo.groupInfo[i].boundingBox1.Y * 2;
double drawx2 = wmo.groupInfo[i].boundingBox2.X * 2;
double drawy2 = wmo.groupInfo[i].boundingBox2.Y * 2;
if (drawx1 < wmo_minx)
{
wmo_minx = (int)drawx1;
}
if (drawx1 > wmo_maxx)
{
wmo_maxx = (int)drawx1;
}
if (drawy1 < wmo_miny)
{
wmo_miny = (int)drawy1;
}
if (drawy1 > wmo_maxy)
{
wmo_maxy = (int)drawy1;
}
if (drawx2 < wmo_minx)
{
wmo_minx = (int)drawx2;
}
if (drawx2 > wmo_maxx)
{
wmo_maxx = (int)drawx2;
}
if (drawy2 < wmo_miny)
{
wmo_minx = (int)drawy2;
}
if (drawy2 > wmo_maxy)
{
wmo_maxx = (int)drawy2;
}
}
int wmoresx = 0;
int wmoresy = 0;
//Determine image height
for (int i = 0; i < wmo.group.Count(); i++)
{
string groupid = i.ToString().PadLeft(3, '0');
double drawx1 = wmo.groupInfo[i].boundingBox1.X * 2;
double drawy1 = wmo.groupInfo[i].boundingBox1.Y * 2;
double drawx2 = wmo.groupInfo[i].boundingBox2.X * 2;
double drawy2 = wmo.groupInfo[i].boundingBox2.Y * 2;
int greenx1 = (int)drawx1 + Math.Abs(wmo_minx);
int greeny1 = (int)drawy1 + Math.Abs(wmo_miny);
int greenx2 = (int)drawx2 + Math.Abs(wmo_minx);
int greeny2 = (int)drawy2 + Math.Abs(wmo_miny);
if (greenx2 > wmoresx)
{
wmoresx = greenx2;
}
if (greeny2 > wmoresy)
{
wmoresy = greeny2;
}
}
if (wmoresx == 0 || wmoresy == 0)
{
Console.WriteLine("WMO " + wmoname + " has invalid calculated resolution (" + wmoresx + "x" + wmoresy + ")");
return;
}
Bitmap wmobmp = new Bitmap(wmoresx, wmoresy);
Graphics wmog = Graphics.FromImage(wmobmp);
/*
* string wmodirname = Path.GetDirectoryName(wmoname.Replace("World" + Path.DirectorySeparatorChar, String.Empty));
*
* if (!Directory.Exists(Path.Combine(basedir, "World", "Minimaps", wmodirname + Path.DirectorySeparatorChar)))
* {
* Console.WriteLine("WMO has no minimaps directory (" + Path.Combine(basedir, "World", "Minimaps", wmodirname + Path.DirectorySeparatorChar) + "). Skipping..");
* return;
* }
*/
for (int i = 0; i < wmo.group.Count(); i++)
{
string groupid = i.ToString().PadLeft(3, '0');
double drawx1 = wmo.groupInfo[i].boundingBox1.X * 2;
double drawy1 = wmo.groupInfo[i].boundingBox1.Y * 2;
double drawx2 = wmo.groupInfo[i].boundingBox2.X * 2;
double drawy2 = wmo.groupInfo[i].boundingBox2.Y * 2;
int greenx1 = (int)drawx1 + Math.Abs(wmo_minx);
int greeny1 = (int)drawy1 + Math.Abs(wmo_miny);
int greenx2 = (int)drawx2 + Math.Abs(wmo_minx);
int greeny2 = (int)drawy2 + Math.Abs(wmo_miny);
/*
* //Check if minimaps wmo dir for this even exists
*
* string wmogroupfilename = Path.GetFileNameWithoutExtension(wmoname) + "_" + groupid;
* string[] filePaths = Directory.GetFiles(Path.Combine(basedir, "World", "Minimaps", wmodirname + Path.DirectorySeparatorChar), wmogroupfilename + "*");
*
* //check if there are any minimap blps for this group
* if (filePaths.Count() == 0)
* {
* Console.WriteLine("WMO has no blps in minimap directory. Skipping..");
* continue;
* }
*/
Bitmap minimapbmp = CompileGroup(wmoname, groupid);
if (minimapbmp.Width > 1)
{
wmog.DrawImage(minimapbmp, greenx1, (wmoresy - (greeny1 + (greeny2 - greeny1)) + (greeny2 - greeny1)), new Rectangle(0, minimapbmp.Height, (greenx2 - greenx1), -(greeny2 - greeny1)), GraphicsUnit.Pixel);
}
numtiles++;
minimapbmp.Dispose();
}
wmog.Dispose();
if (numtiles > 0) //check if it even compiled anything
{
Directory.CreateDirectory("done" + Path.DirectorySeparatorChar + "WMO" + Path.DirectorySeparatorChar + Path.GetDirectoryName(wmoname));
wmobmp.Save("done" + Path.DirectorySeparatorChar + "WMO" + Path.DirectorySeparatorChar + Path.Combine(wmoname) + ".png");
}
else
{
Console.WriteLine("WMO has no minimaps. Skipping..");
}
}
public static Renderer.Structs.WorldModel LoadWMO(string filename, CacheStorage cache, int shaderProgram)
{
if (cache.worldModelBatches.ContainsKey(filename))
{
return(cache.worldModelBatches[filename]);
}
WoWFormatLib.Structs.WMO.WMO wmo = new WoWFormatLib.Structs.WMO.WMO();
if (cache.worldModels.ContainsKey(filename))
{
wmo = cache.worldModels[filename];
}
else
{
//Load WMO from file
if (WoWFormatLib.Utils.CASC.cascHandler.FileExists(filename))
{
var wmoreader = new WMOReader();
wmoreader.LoadWMO(filename, false);
cache.worldModels.Add(filename, wmoreader.wmofile);
wmo = wmoreader.wmofile;
}
else
{
throw new Exception("WMO " + filename + " does not exist!");
}
}
if (wmo.group.Count() == 0)
{
throw new Exception("Broken WMO! Report to developer (mail [email protected]) with this filename: " + filename);
}
var wmobatch = new Renderer.Structs.WorldModel()
{
groupBatches = new Renderer.Structs.WorldModelGroupBatches[wmo.group.Count()]
};
string[] groupNames = new string[wmo.group.Count()];
for (int g = 0; g < wmo.group.Count(); g++)
{
if (wmo.group[g].mogp.vertices == null)
{
continue;
}
wmobatch.groupBatches[g].vao = GL.GenVertexArray();
wmobatch.groupBatches[g].vertexBuffer = GL.GenBuffer();
wmobatch.groupBatches[g].indiceBuffer = GL.GenBuffer();
GL.BindVertexArray(wmobatch.groupBatches[g].vao);
GL.BindBuffer(BufferTarget.ArrayBuffer, wmobatch.groupBatches[g].vertexBuffer);
Renderer.Structs.M2Vertex[] wmovertices = new Renderer.Structs.M2Vertex[wmo.group[g].mogp.vertices.Count()];
for (int i = 0; i < wmo.groupNames.Count(); i++)
{
if (wmo.group[g].mogp.nameOffset == wmo.groupNames[i].offset)
{
groupNames[g] = wmo.groupNames[i].name.Replace(" ", "_");
}
}
if (groupNames[g] == "antiportal")
{
continue;
}
for (int i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
wmovertices[i].Position = new Vector3(wmo.group[g].mogp.vertices[i].vector.X, wmo.group[g].mogp.vertices[i].vector.Y, wmo.group[g].mogp.vertices[i].vector.Z);
wmovertices[i].Normal = new Vector3(wmo.group[g].mogp.normals[i].normal.X, wmo.group[g].mogp.normals[i].normal.Y, wmo.group[g].mogp.normals[i].normal.Z);
if (wmo.group[g].mogp.textureCoords[0] == null)
{
wmovertices[i].TexCoord = new Vector2(0.0f, 0.0f);
}
else
{
wmovertices[i].TexCoord = new Vector2(wmo.group[g].mogp.textureCoords[0][i].X, wmo.group[g].mogp.textureCoords[0][i].Y);
}
}
//Push to buffer
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(wmovertices.Length * 8 * sizeof(float)), wmovertices, BufferUsageHint.StaticDraw);
//Set pointers in buffer
//var normalAttrib = GL.GetAttribLocation(shaderProgram, "normal");
//GL.EnableVertexAttribArray(normalAttrib);
//GL.VertexAttribPointer(normalAttrib, 3, VertexAttribPointerType.Float, false, sizeof(float) * 8, sizeof(float) * 0);
var texCoordAttrib = GL.GetAttribLocation(shaderProgram, "texCoord");
GL.EnableVertexAttribArray(texCoordAttrib);
GL.VertexAttribPointer(texCoordAttrib, 2, VertexAttribPointerType.Float, false, sizeof(float) * 8, sizeof(float) * 3);
var posAttrib = GL.GetAttribLocation(shaderProgram, "position");
GL.EnableVertexAttribArray(posAttrib);
GL.VertexAttribPointer(posAttrib, 3, VertexAttribPointerType.Float, false, sizeof(float) * 8, sizeof(float) * 5);
//Switch to Index buffer
GL.BindBuffer(BufferTarget.ElementArrayBuffer, wmobatch.groupBatches[g].indiceBuffer);
List <uint> wmoindicelist = new List <uint>();
for (int i = 0; i < wmo.group[g].mogp.indices.Count(); i++)
{
wmoindicelist.Add(wmo.group[g].mogp.indices[i].indice);
}
wmobatch.groupBatches[g].indices = wmoindicelist.ToArray();
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(wmobatch.groupBatches[g].indices.Length * sizeof(uint)), wmobatch.groupBatches[g].indices, BufferUsageHint.StaticDraw);
}
GL.Enable(EnableCap.Texture2D);
wmobatch.mats = new Renderer.Structs.Material[wmo.materials.Count()];
for (int i = 0; i < wmo.materials.Count(); i++)
{
wmobatch.mats[i].texture1 = wmo.materials[i].texture1;
wmobatch.mats[i].texture2 = wmo.materials[i].texture2;
wmobatch.mats[i].texture3 = wmo.materials[i].texture3;
for (int ti = 0; ti < wmo.textures.Count(); ti++)
{
if (wmo.textures[ti].startOffset == wmo.materials[i].texture1)
{
wmobatch.mats[i].textureID1 = BLPLoader.LoadTexture(wmo.textures[ti].filename, cache);
}
if (wmo.textures[ti].startOffset == wmo.materials[i].texture2)
{
wmobatch.mats[i].textureID2 = BLPLoader.LoadTexture(wmo.textures[ti].filename, cache);
}
if (wmo.textures[ti].startOffset == wmo.materials[i].texture3)
{
wmobatch.mats[i].textureID3 = BLPLoader.LoadTexture(wmo.textures[ti].filename, cache);
}
}
}
wmobatch.doodads = new Renderer.Structs.WMODoodad[wmo.doodadDefinitions.Count()];
for (int i = 0; i < wmo.doodadDefinitions.Count(); i++)
{
for (int j = 0; j < wmo.doodadNames.Count(); j++)
{
if (wmo.doodadDefinitions[i].offset == wmo.doodadNames[j].startOffset)
{
wmobatch.doodads[i].filename = wmo.doodadNames[j].filename;
//M2Loader.LoadM2(wmobatch.doodads[i].filename, cache);
}
}
wmobatch.doodads[i].flags = wmo.doodadDefinitions[i].flags;
wmobatch.doodads[i].position = new Vector3(wmo.doodadDefinitions[i].position.X, wmo.doodadDefinitions[i].position.Y, wmo.doodadDefinitions[i].position.Z);
wmobatch.doodads[i].rotation = new Quaternion(wmo.doodadDefinitions[i].rotation.X, wmo.doodadDefinitions[i].rotation.Y, wmo.doodadDefinitions[i].rotation.Z, wmo.doodadDefinitions[i].rotation.W);
wmobatch.doodads[i].scale = wmo.doodadDefinitions[i].scale;
wmobatch.doodads[i].color = new Vector4(wmo.doodadDefinitions[i].color[0], wmo.doodadDefinitions[i].color[1], wmo.doodadDefinitions[i].color[2], wmo.doodadDefinitions[i].color[3]);
}
int numRenderbatches = 0;
//Get total amount of render batches
for (int i = 0; i < wmo.group.Count(); i++)
{
if (wmo.group[i].mogp.renderBatches == null)
{
continue;
}
numRenderbatches = numRenderbatches + wmo.group[i].mogp.renderBatches.Count();
}
wmobatch.wmoRenderBatch = new Renderer.Structs.RenderBatch[numRenderbatches];
int rb = 0;
for (int g = 0; g < wmo.group.Count(); g++)
{
var group = wmo.group[g];
if (group.mogp.renderBatches == null)
{
continue;
}
for (int i = 0; i < group.mogp.renderBatches.Count(); i++)
{
wmobatch.wmoRenderBatch[rb].firstFace = group.mogp.renderBatches[i].firstFace;
wmobatch.wmoRenderBatch[rb].numFaces = group.mogp.renderBatches[i].numFaces;
uint matID = 0;
if (group.mogp.renderBatches[i].flags == 2)
{
matID = (uint)group.mogp.renderBatches[i].possibleBox2_3;
}
else
{
matID = group.mogp.renderBatches[i].materialID;
}
wmobatch.wmoRenderBatch[rb].materialID = new uint[3];
for (int ti = 0; ti < wmobatch.mats.Count(); ti++)
{
if (wmo.materials[matID].texture1 == wmobatch.mats[ti].texture1)
{
wmobatch.wmoRenderBatch[rb].materialID[0] = (uint)wmobatch.mats[ti].textureID1;
}
if (wmo.materials[matID].texture2 == wmobatch.mats[ti].texture2)
{
wmobatch.wmoRenderBatch[rb].materialID[1] = (uint)wmobatch.mats[ti].textureID2;
}
if (wmo.materials[matID].texture3 == wmobatch.mats[ti].texture3)
{
wmobatch.wmoRenderBatch[rb].materialID[2] = (uint)wmobatch.mats[ti].textureID3;
}
}
wmobatch.wmoRenderBatch[rb].blendType = wmo.materials[matID].blendMode;
wmobatch.wmoRenderBatch[rb].groupID = (uint)g;
rb++;
}
}
cache.worldModelBatches.Add(filename, wmobatch);
return(wmobatch);
}
static void Main(string[] args)
{
if (args.Length < 2)
{
throw new Exception("Require buildconfig and cdnconfig (and yes for fullrun)");
}
var fullrun = false;
if (args.Length == 3 && args[2] == "1")
{
Console.WriteLine("Doing full run!");
fullrun = true;
}
// TODO: Use configuration stuff instead, but I don't want to figure that out right now. :)
if (!File.Exists("connectionstring.txt"))
{
throw new Exception("connectionstring.txt not found!");
}
var dbConn = new MySqlConnection(File.ReadAllText("connectionstring.txt"));
dbConn.Open();
CASCLib.Logger.Init();
CASC.InitCasc("wow.tools", args[0], args[1]);
var insertCmd = new MySqlCommand("INSERT INTO wow_rootfiles_links VALUES (@parent, @child, @type)", dbConn);
insertCmd.Parameters.AddWithValue("@parent", 0);
insertCmd.Parameters.AddWithValue("@child", 0);
insertCmd.Parameters.AddWithValue("@type", "");
insertCmd.Prepare();
var insertUVFNCmd = new MySqlCommand("INSERT INTO wow_communityfiles VALUES (@id, @filename)", dbConn);
insertUVFNCmd.Parameters.AddWithValue("@id", 0);
insertUVFNCmd.Parameters.AddWithValue("@filename", 0);
insertCmd.Prepare();
#region M2
var m2ids = new List <uint>();
using (var cmd = dbConn.CreateCommand())
{
if (fullrun)
{
cmd.CommandText = "SELECT id from wow_rootfiles WHERE type = 'm2' ORDER BY id DESC";
}
else
{
Console.WriteLine("[M2] Generating list of files to process..");
cmd.CommandText = "SELECT id from wow_rootfiles WHERE type = 'm2' AND id NOT IN (SELECT parent FROM wow_rootfiles_links) ORDER BY id DESC";
}
var reader = cmd.ExecuteReader();
while (reader.Read())
{
m2ids.Add(uint.Parse(reader["id"].ToString()));
}
reader.Close();
}
foreach (var m2 in m2ids)
{
if (CASC.FileExists(m2))
{
Console.WriteLine("[M2] Loading " + m2);
try
{
var reader = new M2Reader();
reader.LoadM2(m2, false);
insertCmd.Parameters[0].Value = m2;
if (reader.model.textureFileDataIDs != null)
{
foreach (var textureID in reader.model.textureFileDataIDs)
{
insertEntry(insertCmd, textureID, "m2 texture");
}
}
if (reader.model.animFileDataIDs != null)
{
foreach (var animFileID in reader.model.animFileDataIDs)
{
insertEntry(insertCmd, animFileID.fileDataID, "m2 anim");
}
}
if (reader.model.skinFileDataIDs != null)
{
foreach (var skinFileID in reader.model.skinFileDataIDs)
{
insertEntry(insertCmd, skinFileID, "m2 skin");
}
}
if (reader.model.boneFileDataIDs != null)
{
foreach (var boneFileID in reader.model.boneFileDataIDs)
{
insertEntry(insertCmd, boneFileID, "m2 bone");
}
}
if (reader.model.recursiveParticleModelFileIDs != null)
{
foreach (var rpID in reader.model.recursiveParticleModelFileIDs)
{
insertEntry(insertCmd, rpID, "m2 recursive particle");
}
}
if (reader.model.geometryParticleModelFileIDs != null)
{
foreach (var gpID in reader.model.geometryParticleModelFileIDs)
{
insertEntry(insertCmd, gpID, "m2 geometry particle");
}
}
insertEntry(insertCmd, reader.model.skelFileID, "m2 skel");
insertEntry(insertCmd, reader.model.physFileID, "m2 phys");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
#endregion
#region WMO
var wmoids = new List <uint>();
var groupFixCMD = new MySqlCommand("UPDATE wow_rootfiles SET type = '_xxxwmo' WHERE id = @id LIMIT 1", dbConn);
groupFixCMD.Parameters.AddWithValue("@id", 0);
groupFixCMD.Prepare();
using (var cmd = dbConn.CreateCommand())
{
if (fullrun)
{
cmd.CommandText = "SELECT id from wow_rootfiles WHERE type = 'wmo' ORDER BY id DESC";
}
else
{
Console.WriteLine("[WMO] Generating list of files to process..");
cmd.CommandText = "SELECT id from wow_rootfiles WHERE type = 'wmo' AND id NOT IN (SELECT parent FROM wow_rootfiles_links) ORDER BY id DESC";
}
var reader = cmd.ExecuteReader();
while (reader.Read())
{
wmoids.Add(uint.Parse(reader["id"].ToString()));
}
reader.Close();
}
foreach (var wmoid in wmoids)
{
if (CASC.FileExists(wmoid))
{
Console.WriteLine("[WMO] Loading " + wmoid);
try
{
var reader = new WMOReader();
var wmo = new WoWFormatLib.Structs.WMO.WMO();
try
{
wmo = reader.LoadWMO(wmoid);
}
catch (NotSupportedException e)
{
Console.WriteLine("[WMO] " + wmoid + " is a group WMO, fixing type and skipping..");
groupFixCMD.Parameters[0].Value = wmoid;
groupFixCMD.ExecuteNonQuery();
continue;
}
insertCmd.Parameters[0].Value = wmoid;
var inserted = new List <uint>();
if (wmo.groupFileDataIDs != null)
{
foreach (var groupFileDataID in wmo.groupFileDataIDs)
{
insertEntry(insertCmd, groupFileDataID, "wmo group");
}
}
if (wmo.doodadIds != null)
{
foreach (var doodadID in wmo.doodadIds)
{
if (inserted.Contains(doodadID))
{
continue;
}
inserted.Add(doodadID);
insertEntry(insertCmd, doodadID, "wmo doodad");
}
}
if (wmo.textures == null && wmo.materials != null)
{
foreach (var material in wmo.materials)
{
if (material.texture1 == 0 || inserted.Contains(material.texture1))
{
continue;
}
inserted.Add(material.texture1);
insertEntry(insertCmd, material.texture1, "wmo texture");
if (material.texture2 == 0 || inserted.Contains(material.texture2))
{
continue;
}
inserted.Add(material.texture2);
insertEntry(insertCmd, material.texture2, "wmo texture");
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
#endregion
#region WDT
var wdtids = new List <uint>();
var wdtfullnamemap = new Dictionary <string, uint>();
using (var cmd = dbConn.CreateCommand())
{
Console.WriteLine("[WDT] Generating list of WDT files..");
cmd.CommandText = "SELECT id, filename from wow_rootfiles WHERE type = 'wdt' AND filename IS NOT NULL ORDER BY id DESC";
var reader = cmd.ExecuteReader();
while (reader.Read())
{
var filename = (string)reader["filename"];
var wdtid = uint.Parse(reader["id"].ToString());
if (filename.Contains("_mpv") || filename.Contains("_lgt") || filename.Contains("_occ") || filename.Contains("_fogs"))
{
continue;
}
wdtfullnamemap.Add(filename, wdtid);
}
}
using (var cmd = dbConn.CreateCommand())
{
if (fullrun)
{
cmd.CommandText = "SELECT id, filename from wow_rootfiles WHERE type = 'wdt' ORDER BY id DESC";
}
else
{
Console.WriteLine("[WDT] Generating list of files to process..");
cmd.CommandText = "SELECT id, filename from wow_rootfiles WHERE type = 'wdt' AND id NOT IN (SELECT parent FROM wow_rootfiles_links) ORDER BY id DESC";
}
var reader = cmd.ExecuteReader();
while (reader.Read())
{
//var filename = (string)reader["filename"];
var wdtid = uint.Parse(reader["id"].ToString());
//if (filename.Contains("_mpv") || filename.Contains("_lgt") || filename.Contains("_occ") || filename.Contains("_fogs"))
// continue;
wdtids.Add(wdtid);
}
reader.Close();
foreach (var wdtid in wdtids)
{
Console.WriteLine("[WDT] Loading " + wdtid);
insertCmd.Parameters[0].Value = wdtid;
try
{
var wdtreader = new WDTReader();
wdtreader.LoadWDT(wdtid);
if (wdtreader.wdtfile.modf.id != 0)
{
Console.WriteLine("WDT has WMO ID: " + wdtreader.wdtfile.modf.id);
insertEntry(insertCmd, wdtreader.wdtfile.modf.id, "wdt wmo");
}
foreach (var records in wdtreader.stringTileFiles)
{
insertEntry(insertCmd, records.Value.rootADT, "root adt");
insertEntry(insertCmd, records.Value.tex0ADT, "tex0 adt");
insertEntry(insertCmd, records.Value.lodADT, "lod adt");
insertEntry(insertCmd, records.Value.obj0ADT, "obj0 adt");
insertEntry(insertCmd, records.Value.obj1ADT, "obj1 adt");
insertEntry(insertCmd, records.Value.mapTexture, "map texture");
insertEntry(insertCmd, records.Value.mapTextureN, "mapn texture");
insertEntry(insertCmd, records.Value.minimapTexture, "minimap texture");
}
}catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
#endregion
#region ADT
var adtids = new Dictionary <uint, Dictionary <(byte, byte), uint> >();
var wdtmapping = new Dictionary <string, uint>();
using (var cmd = dbConn.CreateCommand())
{
if (fullrun)
{
cmd.CommandText = " SELECT id, filename from wow_rootfiles WHERE filename LIKE '%adt' AND filename NOT LIKE '%_obj0.adt' AND filename NOT LIKE '%_obj1.adt' AND filename NOT LIKE '%_lod.adt' AND filename NOT LIKE '%tex0.adt' AND filename NOT LIKE '%tex1.adt' ORDER BY id DESC ";
}
else
{
Console.WriteLine("[ADT] Generating list of files to process..");
cmd.CommandText = " SELECT id, filename from wow_rootfiles WHERE filename LIKE '%adt' AND filename NOT LIKE '%_obj0.adt' AND filename NOT LIKE '%_obj1.adt' AND filename NOT LIKE '%_lod.adt' AND filename NOT LIKE '%tex0.adt' AND filename NOT LIKE '%tex1.adt' AND id NOT IN (SELECT parent FROM wow_rootfiles_links) ORDER BY id DESC";
}
var reader = cmd.ExecuteReader();
while (reader.Read())
{
var filename = (string)reader["filename"];
var mapname = filename.Replace("world/maps/", "").Substring(0, filename.Replace("world/maps/", "").IndexOf("/"));
var exploded = Path.GetFileNameWithoutExtension(filename).Split('_');
for (var i = 0; i < exploded.Length; i++)
{
//Console.WriteLine(i + ": " + exploded[i]);
}
byte tileX = 0;
byte tileY = 0;
if (!byte.TryParse(exploded[exploded.Length - 2], out tileX) || !byte.TryParse(exploded[exploded.Length - 1], out tileY))
{
throw new FormatException("An error occured converting coordinates from " + filename + " to bytes");
}
if (!wdtmapping.ContainsKey(mapname))
{
var wdtname = "world/maps/" + mapname + "/" + mapname + ".wdt";
if (!wdtfullnamemap.ContainsKey(wdtname))
{
Console.WriteLine("Unable to get filedataid for " + mapname + ", skipping...");
wdtmapping.Remove(mapname);
continue;
}
wdtmapping.Add(mapname, wdtfullnamemap[wdtname]);
if (wdtmapping[mapname] == 0)
{
// TODO: Support WDTs removed in current build
Console.WriteLine("Unable to get filedataid for " + mapname + ", skipping...");
wdtmapping.Remove(mapname);
continue;
/*
* var wdtconn = new MySqlConnection(File.ReadAllText("connectionstring.txt"));
* wdtconn.Open();
* using (var wdtcmd = wdtconn.CreateCommand())
* {
* wdtcmd.CommandText = "SELECT id from wow_rootfiles WHERE filename = '" + wdtname + "'";
* var wdtread = wdtcmd.ExecuteReader();
* while (wdtread.Read())
* {
* wdtmapping[mapname] = uint.Parse(wdtread["id"].ToString());
* }
* }
* wdtconn.Close();*/
}
adtids.Add(wdtmapping[mapname], new Dictionary <(byte, byte), uint>());
}
var id = uint.Parse(reader["id"].ToString());
if (id == 0)
{
Console.WriteLine("Root ADT " + tileX + ", " + tileY + " with ID 0 on WDT " + wdtmapping[mapname]);
continue;
}
if (wdtmapping.ContainsKey(mapname))
{
adtids[wdtmapping[mapname]].Add((tileX, tileY), id);
}
}
reader.Close();
foreach (var wdtid in adtids)
{
foreach (var adtid in wdtid.Value)
{
var inserted = new List <uint>();
Console.WriteLine("[ADT] Loading " + adtid.Key.Item1 + ", " + adtid.Key.Item2 + "(" + adtid.Value + ")");
insertCmd.Parameters[0].Value = adtid.Value;
var adtreader = new ADTReader();
try
{
adtreader.LoadADT(wdtid.Key, adtid.Key.Item1, adtid.Key.Item2);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
continue;
}
if (adtreader.adtfile.objects.m2Names.filenames != null)
{
Console.WriteLine(adtid + " is still using old filenames, skipping!");
}
else
{
foreach (var worldmodel in adtreader.adtfile.objects.worldModels.entries)
{
if (inserted.Contains(worldmodel.mwidEntry))
{
continue;
}
inserted.Add(worldmodel.mwidEntry);
insertEntry(insertCmd, worldmodel.mwidEntry, "adt worldmodel");
}
foreach (var doodad in adtreader.adtfile.objects.models.entries)
{
if (inserted.Contains(doodad.mmidEntry))
{
continue;
}
insertEntry(insertCmd, doodad.mmidEntry, "adt doodad");
inserted.Add(doodad.mmidEntry);
}
}
}
}
}
#endregion
}
public static TerrainWindow.WorldModel LoadWMO(string filename, CacheStorage cache)
{
if (cache.worldModelBatches.ContainsKey(filename))
{
return(cache.worldModelBatches[filename]);
}
WoWFormatLib.Structs.WMO.WMO wmo = new WoWFormatLib.Structs.WMO.WMO();
if (cache.worldModels.ContainsKey(filename))
{
wmo = cache.worldModels[filename];
}
else
{
//Load WMO from file
if (WoWFormatLib.Utils.CASC.FileExists(filename))
{
var wmoreader = new WMOReader();
wmoreader.LoadWMO(filename);
cache.worldModels.Add(filename, wmoreader.wmofile);
wmo = wmoreader.wmofile;
}
else
{
throw new Exception("WMO " + filename + " does not exist!");
}
}
var wmobatch = new TerrainWindow.WorldModel();
wmobatch.groupBatches = new TerrainWindow.WorldModelGroupBatches[wmo.group.Count()];
string[] groupNames = new string[wmo.group.Count()];
for (int g = 0; g < wmo.group.Count(); g++)
{
if (wmo.group[g].mogp.vertices == null)
{
continue;
}
wmobatch.groupBatches[g].vertexBuffer = GL.GenBuffer();
wmobatch.groupBatches[g].indiceBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ArrayBuffer, wmobatch.groupBatches[g].vertexBuffer);
TerrainWindow.M2Vertex[] wmovertices = new TerrainWindow.M2Vertex[wmo.group[g].mogp.vertices.Count()];
for (int i = 0; i < wmo.groupNames.Count(); i++)
{
if (wmo.group[g].mogp.nameOffset == wmo.groupNames[i].offset)
{
groupNames[g] = wmo.groupNames[i].name.Replace(" ", "_");
}
}
if (groupNames[g] == "antiportal")
{
continue;
}
for (int i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
wmovertices[i].Position = new Vector3(wmo.group[g].mogp.vertices[i].vector.X, wmo.group[g].mogp.vertices[i].vector.Y, wmo.group[g].mogp.vertices[i].vector.Z);
wmovertices[i].Normal = new Vector3(wmo.group[g].mogp.normals[i].normal.X, wmo.group[g].mogp.normals[i].normal.Y, wmo.group[g].mogp.normals[i].normal.Z);
if (wmo.group[g].mogp.textureCoords[0] == null)
{
wmovertices[i].TexCoord = new Vector2(0.0f, 0.0f);
}
else
{
wmovertices[i].TexCoord = new Vector2(wmo.group[g].mogp.textureCoords[0][i].X, wmo.group[g].mogp.textureCoords[0][i].Y);
}
}
//Push to buffer
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(wmovertices.Length * 8 * sizeof(float)), wmovertices, BufferUsageHint.StaticDraw);
//Switch to Index buffer
GL.BindBuffer(BufferTarget.ElementArrayBuffer, wmobatch.groupBatches[g].indiceBuffer);
List <uint> wmoindicelist = new List <uint>();
for (int i = 0; i < wmo.group[g].mogp.indices.Count(); i++)
{
wmoindicelist.Add(wmo.group[g].mogp.indices[i].indice);
}
wmobatch.groupBatches[g].indices = wmoindicelist.ToArray();
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(wmobatch.groupBatches[g].indices.Length * sizeof(uint)), wmobatch.groupBatches[g].indices, BufferUsageHint.StaticDraw);
}
GL.Enable(EnableCap.Texture2D);
wmobatch.mats = new TerrainWindow.Material[wmo.materials.Count()];
for (int i = 0; i < wmo.materials.Count(); i++)
{
for (int ti = 0; ti < wmo.textures.Count(); ti++)
{
if (wmo.textures[ti].startOffset == wmo.materials[i].texture1)
{
wmobatch.mats[i].texture1 = wmo.materials[i].texture1;
wmobatch.mats[i].textureID = BLPLoader.LoadTexture(wmo.textures[ti].filename, cache);
wmobatch.mats[i].filename = wmo.textures[ti].filename;
}
}
}
wmobatch.doodads = new TerrainWindow.WMODoodad[wmo.doodadDefinitions.Count()];
for (int i = 0; i < wmo.doodadDefinitions.Count(); i++)
{
for (int j = 0; j < wmo.doodadNames.Count(); j++)
{
if (wmo.doodadDefinitions[i].offset == wmo.doodadNames[j].startOffset)
{
wmobatch.doodads[i].filename = wmo.doodadNames[j].filename;
M2Loader.LoadM2(wmobatch.doodads[i].filename, cache);
}
}
wmobatch.doodads[i].flags = wmo.doodadDefinitions[i].flags;
wmobatch.doodads[i].position = new Vector3(wmo.doodadDefinitions[i].position.X, wmo.doodadDefinitions[i].position.Y, wmo.doodadDefinitions[i].position.Z);
wmobatch.doodads[i].rotation = new Quaternion(wmo.doodadDefinitions[i].rotation.X, wmo.doodadDefinitions[i].rotation.Y, wmo.doodadDefinitions[i].rotation.Z, wmo.doodadDefinitions[i].rotation.W);
wmobatch.doodads[i].scale = wmo.doodadDefinitions[i].scale;
wmobatch.doodads[i].color = new Vector4(wmo.doodadDefinitions[i].color[0], wmo.doodadDefinitions[i].color[1], wmo.doodadDefinitions[i].color[2], wmo.doodadDefinitions[i].color[3]);
}
int numRenderbatches = 0;
//Get total amount of render batches
for (int i = 0; i < wmo.group.Count(); i++)
{
if (wmo.group[i].mogp.renderBatches == null)
{
continue;
}
numRenderbatches = numRenderbatches + wmo.group[i].mogp.renderBatches.Count();
}
wmobatch.wmoRenderBatch = new TerrainWindow.RenderBatch[numRenderbatches];
int rb = 0;
for (int g = 0; g < wmo.group.Count(); g++)
{
var group = wmo.group[g];
if (group.mogp.renderBatches == null)
{
continue;
}
for (int i = 0; i < group.mogp.renderBatches.Count(); i++)
{
wmobatch.wmoRenderBatch[rb].firstFace = group.mogp.renderBatches[i].firstFace;
wmobatch.wmoRenderBatch[rb].numFaces = group.mogp.renderBatches[i].numFaces;
uint matID = 0;
if (group.mogp.renderBatches[i].flags == 2)
{
matID = (uint)group.mogp.renderBatches[i].possibleBox2_3;
}
else
{
matID = group.mogp.renderBatches[i].materialID;
}
for (int ti = 0; ti < wmobatch.mats.Count(); ti++)
{
if (wmo.materials[matID].texture1 == wmobatch.mats[ti].texture1)
{
wmobatch.wmoRenderBatch[rb].materialID = new uint[] { (uint)wmobatch.mats[ti].textureID };
}
}
wmobatch.wmoRenderBatch[rb].blendType = wmo.materials[group.mogp.renderBatches[i].materialID].blendMode;
wmobatch.wmoRenderBatch[rb].groupID = (uint)g;
rb++;
}
}
cache.worldModelBatches.Add(filename, wmobatch);
return(wmobatch);
}
public static TerrainWindow.WorldModel LoadWMO(string filename, CacheStorage cache)
{
if (cache.worldModelBatches.ContainsKey(filename))
{
return cache.worldModelBatches[filename];
}
WoWFormatLib.Structs.WMO.WMO wmo = new WoWFormatLib.Structs.WMO.WMO();
if (cache.worldModels.ContainsKey(filename))
{
wmo = cache.worldModels[filename];
}
else
{
//Load WMO from file
if (WoWFormatLib.Utils.CASC.FileExists(filename))
{
var wmoreader = new WMOReader();
wmoreader.LoadWMO(filename);
cache.worldModels.Add(filename, wmoreader.wmofile);
wmo = wmoreader.wmofile;
}
else
{
throw new Exception("WMO " + filename + " does not exist!");
}
}
var wmobatch = new TerrainWindow.WorldModel();
wmobatch.groupBatches = new TerrainWindow.WorldModelGroupBatches[wmo.group.Count()];
string[] groupNames = new string[wmo.group.Count()];
for (int g = 0; g < wmo.group.Count(); g++)
{
if (wmo.group[g].mogp.vertices == null) { continue; }
wmobatch.groupBatches[g].vertexBuffer = GL.GenBuffer();
wmobatch.groupBatches[g].indiceBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ArrayBuffer, wmobatch.groupBatches[g].vertexBuffer);
TerrainWindow.M2Vertex[] wmovertices = new TerrainWindow.M2Vertex[wmo.group[g].mogp.vertices.Count()];
for (int i = 0; i < wmo.groupNames.Count(); i++)
{
if (wmo.group[g].mogp.nameOffset == wmo.groupNames[i].offset)
{
groupNames[g] = wmo.groupNames[i].name.Replace(" ", "_");
}
}
if (groupNames[g] == "antiportal") { continue; }
for (int i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
wmovertices[i].Position = new Vector3(wmo.group[g].mogp.vertices[i].vector.X, wmo.group[g].mogp.vertices[i].vector.Y, wmo.group[g].mogp.vertices[i].vector.Z);
wmovertices[i].Normal = new Vector3(wmo.group[g].mogp.normals[i].normal.X, wmo.group[g].mogp.normals[i].normal.Y, wmo.group[g].mogp.normals[i].normal.Z);
if (wmo.group[g].mogp.textureCoords[0] == null)
{
wmovertices[i].TexCoord = new Vector2(0.0f, 0.0f);
}
else
{
wmovertices[i].TexCoord = new Vector2(wmo.group[g].mogp.textureCoords[0][i].X, wmo.group[g].mogp.textureCoords[0][i].Y);
}
}
//Push to buffer
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(wmovertices.Length * 8 * sizeof(float)), wmovertices, BufferUsageHint.StaticDraw);
//Switch to Index buffer
GL.BindBuffer(BufferTarget.ElementArrayBuffer, wmobatch.groupBatches[g].indiceBuffer);
List<uint> wmoindicelist = new List<uint>();
for (int i = 0; i < wmo.group[g].mogp.indices.Count(); i++)
{
wmoindicelist.Add(wmo.group[g].mogp.indices[i].indice);
}
wmobatch.groupBatches[g].indices = wmoindicelist.ToArray();
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(wmobatch.groupBatches[g].indices.Length * sizeof(uint)), wmobatch.groupBatches[g].indices, BufferUsageHint.StaticDraw);
}
GL.Enable(EnableCap.Texture2D);
wmobatch.mats = new TerrainWindow.Material[wmo.materials.Count()];
for (int i = 0; i < wmo.materials.Count(); i++)
{
for (int ti = 0; ti < wmo.textures.Count(); ti++)
{
if (wmo.textures[ti].startOffset == wmo.materials[i].texture1)
{
wmobatch.mats[i].texture1 = wmo.materials[i].texture1;
wmobatch.mats[i].textureID = BLPLoader.LoadTexture(wmo.textures[ti].filename, cache);
wmobatch.mats[i].filename = wmo.textures[ti].filename;
}
}
}
wmobatch.doodads = new TerrainWindow.WMODoodad[wmo.doodadDefinitions.Count()];
for(int i = 0; i < wmo.doodadDefinitions.Count(); i++)
{
for(int j = 0; j < wmo.doodadNames.Count(); j++)
{
if (wmo.doodadDefinitions[i].offset == wmo.doodadNames[j].startOffset)
{
wmobatch.doodads[i].filename = wmo.doodadNames[j].filename;
M2Loader.LoadM2(wmobatch.doodads[i].filename, cache);
}
}
wmobatch.doodads[i].flags = wmo.doodadDefinitions[i].flags;
wmobatch.doodads[i].position = new Vector3(wmo.doodadDefinitions[i].position.X, wmo.doodadDefinitions[i].position.Y, wmo.doodadDefinitions[i].position.Z);
wmobatch.doodads[i].rotation = new Quaternion(wmo.doodadDefinitions[i].rotation.X, wmo.doodadDefinitions[i].rotation.Y, wmo.doodadDefinitions[i].rotation.Z, wmo.doodadDefinitions[i].rotation.W);
wmobatch.doodads[i].scale = wmo.doodadDefinitions[i].scale;
wmobatch.doodads[i].color = new Vector4(wmo.doodadDefinitions[i].color[0], wmo.doodadDefinitions[i].color[1], wmo.doodadDefinitions[i].color[2], wmo.doodadDefinitions[i].color[3]);
}
int numRenderbatches = 0;
//Get total amount of render batches
for (int i = 0; i < wmo.group.Count(); i++)
{
if (wmo.group[i].mogp.renderBatches == null) { continue; }
numRenderbatches = numRenderbatches + wmo.group[i].mogp.renderBatches.Count();
}
wmobatch.wmoRenderBatch = new TerrainWindow.RenderBatch[numRenderbatches];
int rb = 0;
for (int g = 0; g < wmo.group.Count(); g++)
{
var group = wmo.group[g];
if (group.mogp.renderBatches == null) { continue; }
for (int i = 0; i < group.mogp.renderBatches.Count(); i++)
{
wmobatch.wmoRenderBatch[rb].firstFace = group.mogp.renderBatches[i].firstFace;
wmobatch.wmoRenderBatch[rb].numFaces = group.mogp.renderBatches[i].numFaces;
uint matID = 0;
if (group.mogp.renderBatches[i].flags == 2)
{
matID = (uint) group.mogp.renderBatches[i].possibleBox2_3;
}
else
{
matID = group.mogp.renderBatches[i].materialID;
}
for (int ti = 0; ti < wmobatch.mats.Count(); ti++)
{
if (wmo.materials[matID].texture1 == wmobatch.mats[ti].texture1)
{
wmobatch.wmoRenderBatch[rb].materialID = new uint[] { (uint)wmobatch.mats[ti].textureID };
}
}
wmobatch.wmoRenderBatch[rb].blendType = wmo.materials[group.mogp.renderBatches[i].materialID].blendMode;
wmobatch.wmoRenderBatch[rb].groupID = (uint)g;
rb++;
}
}
cache.worldModelBatches.Add(filename, wmobatch);
return wmobatch;
}
public static void ExportWMO(string file, string destinationOverride = null, string outdir = "", uint filedataid = 0)
{
Console.WriteLine("WMO glTF Exporter: Loading file {0}...", file);
Console.WriteLine(filedataid);
var wmo = new WoWFormatLib.Structs.WMO.WMO();
if (filedataid != 0)
{
wmo = new WMOReader().LoadWMO(CASC.OpenFile(filedataid));
}
else
{
throw new Exception("Unsupported WMO for exporting! Use FileDataID!");
//wmo = new WMOReader().LoadWMO(file);
}
file = file.Replace("\\", "/");
var customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
if (destinationOverride == null)
{
if (!Directory.Exists(Path.Combine(outdir, Path.GetDirectoryName(file))))
{
Directory.CreateDirectory(Path.Combine(outdir, Path.GetDirectoryName(file)));
}
}
var glTF = new glTF()
{
asset = new Asset()
{
version = "2.0",
generator = "Marlamin's WoW Exporter " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(),
copyright = "Contents are owned by Blizzard Entertainment",
minVersion = "2.0"
}
};
var groups = new Structs.WMOGroup[wmo.group.Count()];
FileStream stream;
if (destinationOverride == null)
{
stream = new FileStream(Path.Combine(outdir, file.Replace(".wmo", ".bin")), FileMode.OpenOrCreate);
}
else
{
stream = new FileStream(Path.Combine(destinationOverride, Path.GetFileNameWithoutExtension(file) + ".bin"), FileMode.OpenOrCreate);
}
var writer = new BinaryWriter(stream);
var bufferViews = new List <BufferView>();
var accessorInfo = new List <Accessor>();
var meshes = new List <Mesh>();
for (var g = 0; g < wmo.group.Count(); g++)
{
if (wmo.group[g].mogp.vertices == null)
{
Console.WriteLine("Group has no vertices!");
continue;
}
if (wmo.group[g].mogp.renderBatches == null)
{
Console.WriteLine("Group has no renderbatches!");
continue;
}
for (var i = 0; i < wmo.groupNames.Count(); i++)
{
if (wmo.group[g].mogp.nameOffset == wmo.groupNames[i].offset)
{
groups[g].name = wmo.groupNames[i].name.Replace(" ", "_");
}
}
if (groups[g].name == "antiportal")
{
Console.WriteLine("Group is antiportal"); continue;
}
// Position bufferview
var vPosBuffer = new BufferView()
{
buffer = 0,
byteOffset = (uint)writer.BaseStream.Position,
target = 34962
};
var minPosX = float.MaxValue;
var minPosY = float.MaxValue;
var minPosZ = float.MaxValue;
var maxPosX = float.MinValue;
var maxPosY = float.MinValue;
var maxPosZ = float.MinValue;
for (var i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
writer.Write(wmo.group[g].mogp.vertices[i].vector.X * -1);
writer.Write(wmo.group[g].mogp.vertices[i].vector.Z);
writer.Write(wmo.group[g].mogp.vertices[i].vector.Y);
if (wmo.group[g].mogp.vertices[i].vector.X * -1 < minPosX)
{
minPosX = wmo.group[g].mogp.vertices[i].vector.X * -1;
}
if (wmo.group[g].mogp.vertices[i].vector.Z < minPosY)
{
minPosY = wmo.group[g].mogp.vertices[i].vector.Z;
}
if (wmo.group[g].mogp.vertices[i].vector.Y < minPosZ)
{
minPosZ = wmo.group[g].mogp.vertices[i].vector.Y;
}
if (wmo.group[g].mogp.vertices[i].vector.X * -1 > maxPosX)
{
maxPosX = wmo.group[g].mogp.vertices[i].vector.X * -1;
}
if (wmo.group[g].mogp.vertices[i].vector.Z > maxPosY)
{
maxPosY = wmo.group[g].mogp.vertices[i].vector.Z;
}
if (wmo.group[g].mogp.vertices[i].vector.Y > maxPosZ)
{
maxPosZ = wmo.group[g].mogp.vertices[i].vector.Y;
}
}
vPosBuffer.byteLength = (uint)writer.BaseStream.Position - vPosBuffer.byteOffset;
var posLoc = accessorInfo.Count();
accessorInfo.Add(new Accessor()
{
name = "vPos",
bufferView = bufferViews.Count(),
byteOffset = 0,
componentType = 5126,
count = (uint)wmo.group[g].mogp.vertices.Count(),
type = "VEC3",
min = new float[] { minPosX, minPosY, minPosZ },
max = new float[] { maxPosX, maxPosY, maxPosZ }
});
bufferViews.Add(vPosBuffer);
// Normal bufferview
var normalBuffer = new BufferView()
{
buffer = 0,
byteOffset = (uint)writer.BaseStream.Position,
target = 34962
};
for (var i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
writer.Write(wmo.group[g].mogp.normals[i].normal.X);
writer.Write(wmo.group[g].mogp.normals[i].normal.Z);
writer.Write(wmo.group[g].mogp.normals[i].normal.Y);
}
normalBuffer.byteLength = (uint)writer.BaseStream.Position - normalBuffer.byteOffset;
var normalLoc = accessorInfo.Count();
accessorInfo.Add(new Accessor()
{
name = "vNormal",
bufferView = bufferViews.Count(),
byteOffset = 0,
componentType = 5126,
count = (uint)wmo.group[g].mogp.vertices.Count(),
type = "VEC3"
});
bufferViews.Add(normalBuffer);
// TexCoord bufferview
var texCoordBuffer = new BufferView()
{
buffer = 0,
byteOffset = (uint)writer.BaseStream.Position,
target = 34962
};
for (var i = 0; i < wmo.group[g].mogp.vertices.Count(); i++)
{
writer.Write(wmo.group[g].mogp.textureCoords[0][i].X);
writer.Write(wmo.group[g].mogp.textureCoords[0][i].Y);
}
texCoordBuffer.byteLength = (uint)writer.BaseStream.Position - texCoordBuffer.byteOffset;
var texLoc = accessorInfo.Count();
accessorInfo.Add(new Accessor()
{
name = "vTex",
bufferView = bufferViews.Count(),
byteOffset = 0,
componentType = 5126,
count = (uint)wmo.group[g].mogp.vertices.Count(),
type = "VEC2"
});
bufferViews.Add(texCoordBuffer);
var indexBufferPos = bufferViews.Count();
for (var i = 0; i < wmo.group[g].mogp.renderBatches.Count(); i++)
{
var batch = wmo.group[g].mogp.renderBatches[i];
accessorInfo.Add(new Accessor()
{
name = "indices",
bufferView = indexBufferPos,
byteOffset = batch.firstFace * 2,
componentType = 5123,
count = batch.numFaces,
type = "SCALAR"
});
var mesh = new Mesh();
mesh.name = groups[g].name + "_" + i;
mesh.primitives = new Primitive[1];
mesh.primitives[0].attributes = new Dictionary <string, int>
{
{ "POSITION", posLoc },
{ "NORMAL", normalLoc },
{ "TEXCOORD_0", texLoc }
};
mesh.primitives[0].indices = (uint)accessorInfo.Count() - 1;
if (batch.flags == 2)
{
mesh.primitives[0].material = (uint)batch.possibleBox2_3;
}
else
{
mesh.primitives[0].material = batch.materialID;
}
mesh.primitives[0].mode = 4;
meshes.Add(mesh);
}
var indiceBuffer = new BufferView()
{
buffer = 0,
byteOffset = (uint)writer.BaseStream.Position,
target = 34963
};
for (var i = 0; i < wmo.group[g].mogp.indices.Count(); i++)
{
writer.Write(wmo.group[g].mogp.indices[i].indice);
}
indiceBuffer.byteLength = (uint)writer.BaseStream.Position - indiceBuffer.byteOffset;
bufferViews.Add(indiceBuffer);
if ((indiceBuffer.byteOffset + indiceBuffer.byteLength) % 4 != 0)
{
writer.Write((short)0);
}
}
glTF.bufferViews = bufferViews.ToArray();
glTF.accessors = accessorInfo.ToArray();
glTF.buffers = new Buffer[1];
glTF.buffers[0].byteLength = (uint)writer.BaseStream.Length;
glTF.buffers[0].uri = Path.GetFileNameWithoutExtension(file) + ".bin";
writer.Close();
writer.Dispose();
if (wmo.materials == null)
{
Console.WriteLine("WMO glTF exporter: Materials empty"); return;
}
var materialCount = wmo.materials.Count();
glTF.images = new Image[materialCount];
glTF.textures = new Texture[materialCount];
glTF.materials = new Material[materialCount];
for (var i = 0; i < materialCount; i++)
{
// Check if texture is a filedataid
if (wmo.textures == null && CASC.FileExists(wmo.materials[i].texture1))
{
var saveLocation = "";
if (destinationOverride == null)
{
saveLocation = Path.Combine(outdir, wmo.materials[i].texture1.ToString() + ".blp");
}
else
{
saveLocation = Path.Combine(outdir, destinationOverride, wmo.materials[i].texture1.ToString() + ".blp");
}
if (!File.Exists(Path.GetFileNameWithoutExtension(saveLocation) + "png")) // Check if already exported & converted version exists
{
using (var cascFile = CASC.OpenFile(wmo.materials[i].texture1))
using (var cascStream = new MemoryStream())
{
cascFile.CopyTo(cascStream);
File.WriteAllBytes(saveLocation, cascStream.ToArray());
}
}
glTF.images[i].uri = wmo.materials[i].texture1.ToString() + ".png";
glTF.textures[i].sampler = 0;
glTF.textures[i].source = i;
glTF.materials[i].name = wmo.materials[i].texture1.ToString();
glTF.materials[i].pbrMetallicRoughness = new PBRMetallicRoughness();
glTF.materials[i].pbrMetallicRoughness.baseColorTexture = new TextureIndex();
glTF.materials[i].pbrMetallicRoughness.baseColorTexture.index = i;
glTF.materials[i].pbrMetallicRoughness.metallicFactor = 0.0f;
glTF.materials[i].doubleSided = true;
switch (wmo.materials[i].blendMode)
{
case 0:
glTF.materials[i].alphaMode = "OPAQUE";
glTF.materials[i].alphaCutoff = 0.0f;
break;
case 1:
glTF.materials[i].alphaMode = "MASK";
glTF.materials[i].alphaCutoff = 0.90393700787f;
break;
case 2:
glTF.materials[i].alphaMode = "MASK";
glTF.materials[i].alphaCutoff = 0.5f;
break;
default:
glTF.materials[i].alphaMode = "OPAQUE";
glTF.materials[i].alphaCutoff = 0.0f;
break;
}
}
else
{
if (wmo.textures == null)
{
throw new Exception("WMO textures do not exist or are invalid filedataid!");
}
for (var ti = 0; ti < wmo.textures.Count(); ti++)
{
if (wmo.textures[ti].startOffset == wmo.materials[i].texture1)
{
var saveLocation = "";
var textureFilename = Path.GetFileNameWithoutExtension(wmo.textures[ti].filename.Replace("\\", "/")).ToLower();
if (destinationOverride == null)
{
saveLocation = Path.Combine(outdir, textureFilename + ".blp");
}
else
{
saveLocation = Path.Combine(outdir, destinationOverride, textureFilename + ".blp");
}
if (!File.Exists(Path.ChangeExtension(saveLocation, ".blp")) && !File.Exists(Path.ChangeExtension(saveLocation, ".png"))) // Check if already exported & converted version exists
{
using (var cascFile = CASC.OpenFile(wmo.textures[ti].filename))
using (var cascStream = new MemoryStream())
{
cascFile.CopyTo(cascStream);
File.WriteAllBytes(saveLocation, cascStream.ToArray());
}
}
Console.WriteLine(textureFilename);
glTF.images[i].uri = textureFilename + ".png";
glTF.textures[i].sampler = 0;
glTF.textures[i].source = i;
glTF.materials[i].name = textureFilename;
glTF.materials[i].pbrMetallicRoughness = new PBRMetallicRoughness();
glTF.materials[i].pbrMetallicRoughness.baseColorTexture = new TextureIndex();
glTF.materials[i].pbrMetallicRoughness.baseColorTexture.index = i;
glTF.materials[i].pbrMetallicRoughness.metallicFactor = 0.0f;
glTF.materials[i].doubleSided = true;
switch (wmo.materials[i].blendMode)
{
case 0:
glTF.materials[i].alphaMode = "OPAQUE";
glTF.materials[i].alphaCutoff = 0.0f;
break;
case 1:
glTF.materials[i].alphaMode = "MASK";
glTF.materials[i].alphaCutoff = 0.90393700787f;
break;
case 2:
glTF.materials[i].alphaMode = "MASK";
glTF.materials[i].alphaCutoff = 0.5f;
break;
default:
glTF.materials[i].alphaMode = "OPAQUE";
glTF.materials[i].alphaCutoff = 0.0f;
break;
}
}
}
}
}
glTF.samplers = new Sampler[1];
glTF.samplers[0].name = "Default Sampler";
glTF.samplers[0].minFilter = 9986;
glTF.samplers[0].magFilter = 9729;
glTF.samplers[0].wrapS = 10497;
glTF.samplers[0].wrapT = 10497;
glTF.scenes = new Scene[1];
glTF.scenes[0].name = Path.GetFileNameWithoutExtension(file);
glTF.nodes = new Node[meshes.Count()];
var meshIDs = new List <int>();
for (var i = 0; i < meshes.Count(); i++)
{
glTF.nodes[i].name = meshes[i].name;
glTF.nodes[i].mesh = i;
meshIDs.Add(i);
}
glTF.scenes[0].nodes = meshIDs.ToArray();
glTF.meshes = meshes.ToArray();
glTF.scene = 0;
var currentDoodadSetName = "";
for (var i = 0; i < wmo.doodadDefinitions.Count(); i++)
{
var doodadDefinition = wmo.doodadDefinitions[i];
foreach (var doodadSet in wmo.doodadSets)
{
if (doodadSet.firstInstanceIndex == i)
{
Console.WriteLine("At set: " + doodadSet.setName);
currentDoodadSetName = doodadSet.setName.Replace("Set_", "").Replace("SET_", "").Replace("$DefaultGlobal", "Default");
}
}
if (wmo.doodadIds != null)
{
var doodadFileDataID = wmo.doodadIds[doodadDefinition.offset];
if (!File.Exists(doodadFileDataID + ".gltf"))
{
if (destinationOverride == null)
{
//M2Exporter.ExportM2(doodadFileDataID, null, Path.Combine(outdir, Path.GetDirectoryName(file)));
}
else
{
//M2Exporter.ExportM2(doodadFileDataID, null, destinationOverride);
}
}
}
else
{
if (wmo.doodadNames != null)
{
foreach (var doodadNameEntry in wmo.doodadNames)
{
if (doodadNameEntry.startOffset == doodadDefinition.offset)
{
if (!File.Exists(Path.GetFileNameWithoutExtension(doodadNameEntry.filename).ToLower() + ".gltf"))
{
if (destinationOverride == null)
{
//M2Exporter.ExportM2(doodadNameEntry.filename.Replace(".MDX", ".M2").Replace(".MDL", ".M2").ToLower(), null, Path.Combine(outdir, Path.GetDirectoryName(file)));
}
else
{
//M2Exporter.ExportM2(doodadNameEntry.filename.Replace(".MDX", ".M2").Replace(".MDL", ".M2").ToLower(), null, destinationOverride);
}
}
}
}
}
}
}
if (destinationOverride == null)
{
File.WriteAllText(Path.Combine(outdir, file.Replace(".wmo", ".gltf")), JsonConvert.SerializeObject(glTF, Formatting.None, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}));
}
else
{
File.WriteAllText(Path.Combine(destinationOverride, Path.GetFileName(file.ToLower()).Replace(".wmo", ".gltf")), JsonConvert.SerializeObject(glTF, Formatting.None, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}));
}
Console.WriteLine("Done exporting WMO file!");
}
