| public Error ( String message ) : void | ||
| message | String | The message to explain the error |
| return | void | |
public static bool Read(RAFFileListEntry file, ref InibinFile data, Logger logger)
{
bool result = true;
logger.Event("Reading inibin: " + file.FileName);
try
{
// Get the data from the archive
MemoryStream myInput = new MemoryStream( file.GetContent() );
result = ReadCharacterInibin(myInput, ref data, logger);
int end = file.FileName.LastIndexOf("/");
String directory = file.FileName.Substring(0, end);
String archive = file.RAFArchive.RAFFilePath;
archive = archive.Replace("\\", "/");
end = archive.LastIndexOf("/");
archive = archive.Substring(0, end);
data.directory = new DirectoryInfo(archive + "/" + directory);
myInput.Close();
}
catch(Exception e)
{
logger.Error("Unable to open memory stream: " + file.FileName);
logger.Error(e.Message);
result = false;
}
return result;
}
public static bool Read(int skin, IFileEntry file,
ref Dictionary<String, String> animations, Logger logger)
{
bool result = true;
logger.Event("Parsing animation list: " + file.FileName );
try
{
// Get the data from the archive
MemoryStream myInput = new MemoryStream( file.GetContent() );
StreamReader reader = new StreamReader(myInput);
ParseAnimations(skin, reader, ref animations);
reader.Close();
myInput.Close();
}
catch
{
logger.Error("Failed to parse animation list: " + file.FileName);
result = false;
animations.Clear();
}
return result;
}
//Helper Functions.
//(Because nested Try/Catch looks nasty in one function block.)
private static bool ReadBinary(MemoryStream input, ref SKLFile data, Logger logger)
{
bool result = true;
try
{
BinaryReader myFile = new BinaryReader(input, Encoding.ASCII);
result = ReadData(myFile, ref data, logger);
myFile.Close();
}
catch (Exception e)
{
logger.Error("Unable to open binary reader.");
logger.Error(e.Message);
result = false;
}
return result;
}
/// <summary>
/// Read in binary .anm file from RAF.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="data">The contents of the file are stored in here.</param>
/// <returns></returns>
public static bool Read(RAFFileListEntry file, ref ANMFile data, Logger logger)
{
bool result = true;
logger.Event("Reading anm: " + file.FileName);
try
{
// Get the data from the archive
MemoryStream myInput = new MemoryStream( file.GetContent() );
result = ReadBinary(myInput, ref data, logger);
myInput.Close();
}
catch(Exception e)
{
logger.Error("Unable to open memory stream: " + file.FileName);
logger.Error(e.Message);
result = false;
}
return result;
}
//
// Helper creation function.
//
private bool Create(List<float> vertexPositions, List<float> vertexNormals,
List<float> vertexTextureCoordinates, List<uint> indices, Logger logger)
{
bool result = true;
logger.Event("Creating OpenGL static model.");
numIndices = indices.Count;
// Create Vertex Array Object
if (result == true)
{
GL.GenVertexArrays(1, out vao);
}
ErrorCode error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Bind VAO
if (result == true)
{
GL.BindVertexArray(vao);
}
// Create the VBOs
int[] buffers = new int[4];
if (result == true)
{
GL.GenBuffers(4, buffers);
}
// Check for errors
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Store data and bind vertex buffer.
if (result == true)
{
vertexPositionBuffer = buffers[0];
vertexNormalBuffer = buffers[1];
vertexTextureCoordinateBuffer = buffers[2];
indexBuffer = buffers[3];
GL.BindBuffer(BufferTarget.ArrayBuffer, vertexPositionBuffer);
}
//
//
// Set vertex data.
//
//
if (result == true)
{
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertexPositions.Count * sizeof(float)),
vertexPositions.ToArray(), BufferUsageHint.StaticDraw);
}
// Check for errors.
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Put vertices into attribute slot 0.
if (result == true)
{
GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float,
false, 0, 0);
}
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Enable the attribute index.
if (result == true)
{
GL.EnableVertexAttribArray(0);
}
//
//
// Bind normal buffer.
//
//
if (result == true)
{
GL.BindBuffer(BufferTarget.ArrayBuffer, vertexNormalBuffer);
}
// Set normal data.
if (result == true)
{
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertexNormals.Count * sizeof(float)),
vertexNormals.ToArray(), BufferUsageHint.StaticDraw);
}
// Check for errors.
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Put normals into attribute slot 1.
if (result == true)
{
GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float,
false, 0, 0);
}
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Enable the attribute index.
if (result == true)
{
GL.EnableVertexAttribArray(1);
}
//
//
// Bind texture cordinates buffer.
//
//
if (result == true)
{
GL.BindBuffer(BufferTarget.ArrayBuffer, vertexTextureCoordinateBuffer);
}
// Set Texture Coordinate Data
if (result == true)
{
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertexTextureCoordinates.Count * sizeof(float)),
vertexTextureCoordinates.ToArray(), BufferUsageHint.StaticDraw);
}
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Put texture coords into attribute slot 2.
if (result == true)
{
GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float,
false, 0, 0);
}
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Enable the attribute index.
if (result == true)
{
GL.EnableVertexAttribArray(2);
}
// Bind index buffer.
if (result == true)
{
GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);
}
// Set index data.
if (result == true)
{
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Count * sizeof(uint)),
indices.ToArray(), BufferUsageHint.StaticDraw);
}
error = GL.GetError();
if (error != ErrorCode.NoError)
{
result = false;
}
// Unbind VAO from pipeline.
if (result == true)
{
GL.BindVertexArray(0);
}
else
{
logger.Error("Failed to create OpenGL static model.");
}
return result;
}
private static bool ReadData(BinaryReader file, ref ANMFile data, Logger logger)
{
bool result = true;
try
{
// File Header Information.
data.id = new String(file.ReadChars(ANMFile.ID_SIZE));
data.version = file.ReadUInt32();
// Version 0, 1, 2, 3 Code
if (data.version == 0 ||
data.version == 1 ||
data.version == 2 ||
data.version == 3)
{
//
// Header information specific to these versions.
//
data.magic = file.ReadUInt32();
data.numberOfBones = file.ReadUInt32();
data.numberOfFrames = file.ReadUInt32();
data.playbackFPS = file.ReadUInt32();
// Read in all the bones
for (UInt32 i = 0; i < data.numberOfBones; ++i)
{
ANMBone bone = new ANMBone();
bone.name = new String(file.ReadChars(ANMBone.BONE_NAME_LENGTH));
bone.name = RemoveAnimationNamePadding(bone.name);
bone.name = bone.name.ToLower();
// Unknown
file.ReadUInt32();
// For each bone, read in its value at each frame in the animation.
for (UInt32 j = 0; j < data.numberOfFrames; ++j)
{
ANMFrame frame = new ANMFrame();
// Read in the frame's quaternion.
frame.orientation[0] = file.ReadSingle(); // x
frame.orientation[1] = file.ReadSingle(); // y
frame.orientation[2] = file.ReadSingle(); // z
frame.orientation[3] = file.ReadSingle(); // w
// Read in the frame's position.
frame.position[0] = file.ReadSingle(); // x
frame.position[1] = file.ReadSingle(); // y
frame.position[2] = file.ReadSingle(); // z
bone.frames.Add(frame);
}
data.bones.Add(bone);
}
}
// Version 4 Code
else if (data.version == 4)
{
//
// Based on the reverse engineering work of Hossein Ahmadi.
//
// In this version, position vectors and orientation quaternions are
// stored separately in sorted, keyed blocks. The assumption is Riot
// is removing duplicate vectors and quaternions by using an indexing scheme
// to look up values.
//
// So, after the header, there are three data sections: a vector section, a quaternion
// section, and a look up section. The number of vectors and quaternions
// may not match the expected value based on the number of frames and bones. However,
// the number of look ups should match this value and can be used to create the animation.
//
// Header information specific to version 4.
//
data.magic = file.ReadUInt32();
// Not sure what any of these mean.
float unknown = file.ReadSingle();
unknown = file.ReadSingle();
unknown = file.ReadSingle();
data.numberOfBones = file.ReadUInt32();
data.numberOfFrames = file.ReadUInt32();
// Time per frame is stored in this file type. Need to invert it into FPS.
data.playbackFPS = (UInt32) Math.Round(1.0f / file.ReadSingle());
// These are offsets to specific data sections in the file.
UInt32 unknownOffset = file.ReadUInt32();
unknownOffset = file.ReadUInt32();
unknownOffset = file.ReadUInt32();
UInt32 positionOffset = file.ReadUInt32();
UInt32 orientationOffset = file.ReadUInt32();
UInt32 indexOffset = file.ReadUInt32();
// These last three values are confusing.
// They aren't a vector and they throw off the offset values
// by 12 bytes. Just ignore them and keep reading.
unknownOffset = file.ReadUInt32();
unknownOffset = file.ReadUInt32();
unknownOffset = file.ReadUInt32();
//
// Vector section.
//
List<float> positions = new List<float>();
UInt32 numberOfPositions = (orientationOffset - positionOffset) / sizeof(float);
for (UInt32 i = 0; i < numberOfPositions; ++i)
{
positions.Add(file.ReadSingle());
}
//
// Quaternion section.
//
List<float> orientations = new List<float>();
UInt32 numberOfOrientations = (indexOffset - orientationOffset) / sizeof(float);
for (UInt32 i = 0; i < numberOfOrientations; ++i)
{
orientations.Add(file.ReadSingle());
}
//
// Offset section.
//
// Note: Unlike versions 0-3, data in this version is
// Frame 1:
// Bone 1:
// Bone 2:
// ...
// Frame 2:
// Bone 1:
// ...
//
Dictionary<UInt32, ANMBone> boneMap = new Dictionary<UInt32, ANMBone>();
for (Int32 i = 0; i < data.numberOfBones; ++i)
{
//
// The first frame is a special case since we are allocating bones
// as we read them in.
//
// Read in the offset data.
UInt32 boneID = file.ReadUInt32();
UInt16 positionID = file.ReadUInt16();
UInt16 unknownIndex = file.ReadUInt16(); // Unknown.
UInt16 orientationID = file.ReadUInt16();
unknownIndex = file.ReadUInt16(); // Unknown. Seems to always be zero.
// Allocate the bone.
ANMBone bone = new ANMBone();
bone.id = boneID;
// Allocate all the frames for the bone.
for (int j = 0; j < data.numberOfFrames; ++j)
{
bone.frames.Add(new ANMFrame());
}
// Retrieve the data for the first frame.
ANMFrame frame = bone.frames[0];
frame.position = LookUpVector(positionID, positions);
frame.orientation = LookUpQuaternion(orientationID, orientations);
// Store the bone in the dictionary by bone ID.
boneMap[boneID] = bone;
}
Int32 currentFrame = 1;
Int32 currentBone = 0;
UInt32 numberOfLookUps = (data.numberOfFrames - 1) * data.numberOfBones;
for (UInt32 i = 0; i < numberOfLookUps; ++i)
{
//
// Normal case for all frames after the first.
//
// Read in the offset data.
UInt32 boneID = file.ReadUInt32();
UInt16 positionID = file.ReadUInt16();
UInt16 unknownIndex = file.ReadUInt16(); // Unknown.
UInt16 orientationID = file.ReadUInt16();
unknownIndex = file.ReadUInt16(); // Unknown. Seems to always be zero.
// Retrieve the bone from the dictionary.
// Note: The bones appear to be in the same order in every frame. So, a dictionary
// isn't exactly needed and you could probably get away with a list. However, this way
// feels safer just in case something ends up being out of order.
ANMBone bone = boneMap[boneID];
ANMFrame frame = bone.frames[currentFrame];
frame.position = LookUpVector(positionID, positions);
frame.orientation = LookUpQuaternion(orientationID, orientations);
// This loop is slightly ambiguous.
//
// The problem is previous .anm versions contain data like:
// foreach bone
// foreach frame
//
// However, this version contains data like:
// foreach frame
// foreach bone
//
// So, reading one version is going to be a little goofy.
currentBone++;
if (currentBone >= data.numberOfBones)
{
currentBone = 0;
currentFrame++;
}
}
// Finally, we need to move all the data from the dictionary into the ANMFile.
foreach(var bone in boneMap)
{
data.bones.Add(bone.Value);
}
// Currently returning false for this version. We can not render this version correctly yet.
// So, we need to tell the viewer not to try and load it.
result = false;
}
// Unknown version
else
{
logger.Error("Unknown anm version: " + data.version);
result = false;
}
}
catch(Exception e)
{
logger.Error("Anm reading error.");
logger.Error(e.Message);
result = false;
}
logger.Event("File ID: " + data.id);
logger.Event("Magic: " + data.magic);
logger.Event("Version: " + data.version);
logger.Event("Number of Bones: " + data.numberOfBones);
logger.Event("Number of Frames: " + data.numberOfFrames);
logger.Event("Playback FPS: " + data.playbackFPS);
return result;
}
private static bool ReadData(BinaryReader file, ref SKNFile data, Logger logger)
{
bool result = true;
try
{
// File Header Information.
data.magic = file.ReadInt32();
data.version = file.ReadInt16();
data.numObjects = file.ReadInt16();
if (data.version == 1 || data.version == 2)
{
// Contains material headers.
data.numMaterialHeaders = file.ReadInt32();
for (int i = 0; i < data.numMaterialHeaders; ++i)
{
// Read in the headers.
SKNMaterial header = new SKNMaterial();
header.name = new String(file.ReadChars(SKNMaterial.MATERIAL_NAME_SIZE));
header.startVertex = file.ReadInt32();
header.numVertices = file.ReadInt32();
header.startIndex = file.ReadInt32();
header.numIndices = file.ReadInt32();
data.materialHeaders.Add(header);
}
// Read in model data.
data.numIndices = file.ReadInt32();
data.numVertices = file.ReadInt32();
for (int i = 0; i < data.numIndices; ++i)
{
data.indices.Add(file.ReadInt16());
}
for (int i = 0; i < data.numVertices; ++i)
{
SKNVertex vertex = new SKNVertex();
vertex.position[0] = file.ReadSingle(); // x
vertex.position[1] = file.ReadSingle(); // y
vertex.position[2] = file.ReadSingle(); // z
for (int j = 0; j < SKNVertex.BONE_INDEX_SIZE; ++j)
{
int bone = (int)file.ReadByte();
vertex.boneIndex[j] = bone;
}
vertex.weights[0] = file.ReadSingle();
vertex.weights[1] = file.ReadSingle();
vertex.weights[2] = file.ReadSingle();
vertex.weights[3] = file.ReadSingle();
vertex.normal[0] = file.ReadSingle(); // x
vertex.normal[1] = file.ReadSingle(); // y
vertex.normal[2] = file.ReadSingle(); // z
vertex.texCoords[0] = file.ReadSingle(); // u
vertex.texCoords[1] = file.ReadSingle(); // v
data.vertices.Add(vertex);
}
// Data exclusive to version two.
if (data.version == 2)
{
data.endTab.Add(file.ReadInt32());
data.endTab.Add(file.ReadInt32());
data.endTab.Add(file.ReadInt32());
}
}
// Unknown Version
else
{
logger.Error("Unknown skn version: " + data.version);
result = false;
}
}
catch(Exception e)
{
logger.Error("Skn reading error.");
logger.Error(e.Message);
result = false;
}
logger.Event("Magic: " + data.magic);
logger.Event("Version: " + data.version);
logger.Event("Number of Objects: " + data.numObjects);
logger.Event("Number of Material Headers: " + data.numMaterialHeaders);
logger.Event("Number of Vertices: " + data.numVertices);
logger.Event("Number of Indices: " + data.numIndices);
return result;
}
private static bool ReadData(BinaryReader file, ref SKLFile data, Logger logger)
{
bool result = true;
try
{
// File Header Information.
data.id = new String(file.ReadChars(SKLFile.ID_SIZE));
data.version = file.ReadUInt32();
if (data.version == 1 || data.version == 2)
{
data.designerID = file.ReadUInt32();
// Read in the bones.
data.numBones = file.ReadUInt32();
for (int i = 0; i < data.numBones; ++i)
{
SKLBone bone = new SKLBone();
bone.name = new String(
file.ReadChars(SKLBone.BONE_NAME_SIZE));
bone.name = RemoveBoneNamePadding(bone.name);
bone.name = bone.name.ToLower();
bone.ID = i;
bone.parentID = file.ReadInt32();
bone.scale = file.ReadSingle();
// Read in transform matrix.
float[] orientation = new float[SKLBone.ORIENTATION_SIZE];
for (int j = 0; j < SKLBone.ORIENTATION_SIZE; ++j)
{
orientation[j] = file.ReadSingle();
}
bone.orientation = orientation;
// Position from matrix.
bone.position[0] = orientation[3];
bone.position[1] = orientation[7];
bone.position[2] = orientation[11];
data.bones.Add(bone);
}
// Version two contains bone IDs.
if (data.version == 2)
{
data.numBoneIDs = file.ReadUInt32();
for (uint i = 0; i < data.numBoneIDs; ++i)
{
data.boneIDs.Add(file.ReadUInt32());
}
}
}
// Newest version so far.
else if (data.version == 0)
{
// Header
Int16 zero = file.ReadInt16(); // ?
data.numBones = (uint)file.ReadInt16();
data.numBoneIDs = file.ReadUInt32();
Int16 offsetToVertexData = file.ReadInt16(); // Should be 64.
int unknown = file.ReadInt16(); // ?
int offset1 = file.ReadInt32();
int offsetToAnimationIndices = file.ReadInt32();
int offset2 = file.ReadInt32();
int offset3 = file.ReadInt32();
int offsetToStrings = file.ReadInt32();
// Not sure what this data represents.
// I think it's padding incase more header data is required later.
file.BaseStream.Position += 20;
file.BaseStream.Position = offsetToVertexData;
for (int i = 0; i < data.numBones; ++i)
{
SKLBone bone = new SKLBone();
// The old scale was always 0.1.
// For now, just go with it.
bone.scale = 0.1f;
zero = file.ReadInt16(); // ?
bone.ID = file.ReadInt16();
bone.parentID = file.ReadInt16();
unknown = file.ReadInt16(); // ?
int namehash = file.ReadInt32();
float twoPointOne = file.ReadSingle();
bone.position[0] = file.ReadSingle();
bone.position[1] = file.ReadSingle();
bone.position[2] = file.ReadSingle();
float one = file.ReadSingle(); // ? Maybe scales for X, Y, and Z
one = file.ReadSingle();
one = file.ReadSingle();
bone.orientation[0] = file.ReadSingle();
bone.orientation[1] = file.ReadSingle();
bone.orientation[2] = file.ReadSingle();
bone.orientation[3] = file.ReadSingle();
float ctx = file.ReadSingle(); // ctx
float cty = file.ReadSingle(); // cty
float ctz = file.ReadSingle(); // ctz
data.bones.Add(bone);
// The rest of the bone data is unknown. Maybe padding?
file.BaseStream.Position += 32;
}
file.BaseStream.Position = offset1;
for (int i = 0; i < data.numBones; ++i) // Inds for version 4 animation.
{
// 8 bytes
uint sklID = file.ReadUInt32();
uint anmID = file.ReadUInt32();
data.boneIDMap[anmID] = sklID;
}
file.BaseStream.Position = offsetToAnimationIndices;
for (int i = 0; i < data.numBoneIDs; ++i) // Inds for animation
{
// 2 bytes
UInt16 boneID = file.ReadUInt16();
data.boneIDs.Add(boneID);
}
file.BaseStream.Position = offsetToStrings;
for (int i = 0; i < data.numBones; ++i)
{
// bone names
string name = "";
while (name.Contains('\0') == false)
{
name += new string(file.ReadChars(4));
}
name = RemoveBoneNamePadding(name);
name = name.ToLower();
data.bones[i].name = name;
}
}
// Unknown Version
else
{
logger.Error("Unknown skl version: " + data.version);
result = false;
}
}
catch (Exception e)
{
logger.Error("Skl reading error.");
logger.Error(e.Message);
result = false;
}
logger.Event("File ID: " + data.id);
logger.Event("Version: " + data.version);
logger.Event("Designer ID: " + data.designerID);
logger.Event("Number of Bones: " + data.numBones);
logger.Event("Number of Bone IDs: " + data.numBoneIDs);
return result;
}
/// <summary>
/// Read in binary .dds file from RAF.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="data">The contents of the file are stored in here.</param>
/// <returns></returns>
public static bool Read(RAFFileListEntry file, ref Bitmap bitmap, Logger logger)
{
bool result = true;
logger.Event("Reading dds: " + file.FileName);
try
{
// Create image.
int[] images = new int[1];
Il.ilGenImages(1, images);
// Bind image.
Il.ilBindImage(images[0]);
// Load the image data into DevIL.
byte[] data = file.GetContent();
result = Il.ilLoadL(Il.IL_DDS, data, data.Length);
if (result == true)
{
int width = Il.ilGetInteger(Il.IL_IMAGE_WIDTH);
int height = Il.ilGetInteger(Il.IL_IMAGE_HEIGHT); ;
// Create the bitmap.
bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
Rectangle rect = new Rectangle(0, 0, width, height);
// Store the DevIL image data into the bitmap.
BitmapData bitmapData = bitmap.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
Il.ilConvertImage(Il.IL_BGRA, Il.IL_UNSIGNED_BYTE);
Il.ilCopyPixels(0, 0, 0, width, height, 1, Il.IL_BGRA, Il.IL_UNSIGNED_BYTE, bitmapData.Scan0);
bitmap.UnlockBits(bitmapData);
}
// Free image.
Il.ilDeleteImages(1, images);
if (result == false)
{
throw new System.Exception("Unable to load image data.");
}
}
catch(Exception e)
{
logger.Error("Unable to open dds file: " + file.FileName);
logger.Error(e.Message);
result = false;
}
return result;
}
private bool StoreModel(ModelDefinition def, out LOLModel model, Logger logger)
{
model = new LOLModel();
model.skinNumber = def.skin;
model.animationList = def.anmListKey.ToLower();
// Find the skn.
if (skns.ContainsKey(def.skn))
{
model.skn = skns[def.skn];
}
else
{
logger.Error("Unable to find skn file: " + def.skn);
return false;
}
// Find the skl.
if (skls.ContainsKey(def.skl))
{
model.skl = skls[def.skl];
}
else
{
logger.Error("Unable to find skl file: " + def.skl);
return false;
}
// Find the texture.
if (textures.ContainsKey(def.tex))
{
model.texture = textures[def.tex];
}
else
{
logger.Error("Unable to find texture file: " + def.tex);
return false;
}
return true;
}
private bool StoreAnimations(ref LOLModel model, Logger logger)
{
bool result = true;
Dictionary<String, String> animationStrings =
new Dictionary<String, String>();
// Sanity
if (animationLists.ContainsKey(model.animationList) == true)
{
result = ANMListReader.Read(model.skinNumber - 1, // indexing in animations.list assumes the original skin to be -1
animationLists[model.animationList], ref animationStrings, logger);
}
else
{
logger.Error("Unable to find animation list: " + model.animationList);
}
if (result == true)
{
// Store the animations in the model.
foreach (var a in animationStrings)
{
if (animations.ContainsKey(a.Value) == true)
{
if (model.animations.ContainsKey(a.Key) == false)
{
model.animations.Add(a.Key, animations[a.Value]);
}
else
{
logger.Error("Duplicate animation: " + a.Key);
}
}
else
{
logger.Error("Unable to find animation: " + a.Value);
}
}
}
return result;
}
// Replacement for individual raf reading and individual filetype searching
// Provide the directory of RADS\projects\lol_game_client\filearchives or the equivalent
private bool ReadRAFs(DirectoryInfo dir, Logger logger)
{
try
{
RAFMasterFileList rafFiles = new RAFMasterFileList(dir.FullName);
logger.Event("Opening the 'filearchives' directory: " + dir.FullName);
foreach (RAFMasterFileList.RAFSearchResult result in rafFiles.SearchFileEntries(new string[] { ".dds", ".skn", ".skl", ".inibin", "animations.list", ".anm" }, RAFMasterFileList.RAFSearchType.All))
{
RAFFileListEntry e = result.value;
// Split off the actual file name from the full path
String name = e.FileName.Substring(e.FileName.LastIndexOf('/') + 1).ToLower();
switch (result.searchPhrase)
{
case ".dds":
// Try to parse out unwanted textures.
if (!e.FileName.ToLower().Contains("loadscreen") &&
!e.FileName.ToLower().Contains("circle") &&
!e.FileName.ToLower().Contains("square") &&
e.FileName.ToLower().Contains("data") &&
e.FileName.ToLower().Contains("characters"))
{
// Check that the file isn't already in the dictionary
if (!textures.ContainsKey(name))
{
textures.Add(name, e);
}
else
{
logger.Warning("Duplicate texture " + name + ": " + e.FileName);
}
}
break;
case ".skn":
if (!skns.ContainsKey(name))
{
skns.Add(name, e);
}
else
{
logger.Warning("Duplicate skn " + name + ": " + e.FileName);
}
break;
case ".skl":
if (!skls.ContainsKey(name))
{
skls.Add(name, e);
}
else
{
logger.Warning("Duplicate skn " + name + ": " + e.FileName);
}
break;
case ".inibin":
// Try to only read champion inibins
if (e.FileName.ToLower().Contains("data") &&
e.FileName.ToLower().Contains("characters"))
{
inibins.Add(e);
}
else
{
logger.Warning("Excluding inibin " + name + ": " + e.FileName);
}
break;
case "animations.list":
// Riot changed their directory structure for some skins.
// Originally, champion Animation.list files were stored in a directory structure like
// "*/ChampionName/Animation.list". Now, some are stored like
// "*/ChampionName/Skins/Skin01/Animation.list".
if (e.FileName.ToLower().Contains("skin") == false &&
e.FileName.ToLower().Contains("base") == false)
{
// Original Case.
// Remove the file name.
name = e.FileName.Remove(e.FileName.LastIndexOf('/'));
// Remove proceeding directories to get the parent directory
name = name.Substring(name.LastIndexOf('/') + 1).ToLower();
}
else
{
// Newer Case.
string path = e.FileName.ToString();
string[] splitPath = path.Split('/');
// Sanity
if (splitPath.Length > 3)
{
name = splitPath[splitPath.Length - 4].ToLower();
}
}
// Store.
if (!animationLists.ContainsKey(name))
{
animationLists.Add(name, e);
}
else
{
logger.Warning("Duplicate animation list " + name + ": " + e.FileName);
}
break;
case ".anm":
// Remove the .anm extension.
name = name.Remove(name.Length - 4);
if (!animations.ContainsKey(name))
{
animations.Add(name, e);
}
else
{
logger.Warning("Duplicate anm " + name + ": " + e.FileName);
}
break;
}
}
}
catch (Exception e)
{
// Something went wrong. Most likely the RAF read failed due to a bad directory.
logger.Error("Failed to open RAFs");
logger.Error(e.Message);
return false;
}
return true;
}
private void GenerateModelDefinitions(Logger logger)
{
foreach (RAFFileListEntry f in inibins)
{
InibinFile iniFile = new InibinFile();
bool readResult = InibinReader.Read(f, ref iniFile, logger);
if (readResult == true)
{
// Add the models from this .inibin file
List<ModelDefinition> modelDefs = iniFile.GetModelStrings();
for (int j = 0; j < modelDefs.Count; ++j)
{
// Name the model after the parent directory
// of the .inibin plus the name from the .inibin.
// Some things overlap without both.
string path = f.FileName;
string[] splitPath = path.Split('/');
string directoryName = splitPath[splitPath.Length - 2];
if (directoryName.Contains("Base") == true ||
directoryName.Contains("Skin") == true)
{
// The directory structure for this case will be something like
// "*/ChampionName/Skins/Base/".
// We just want the "ChampionName".
directoryName = splitPath[splitPath.Length - 4];
}
// Sometimes the name from the .inibin file is "".
// So, just name it after the directory
String name = modelDefs[j].name;
if (name == "")
{
name = directoryName + "/" + directoryName;
}
else
{
name = directoryName + "/" + name;
}
try
{
LOLModel model;
bool storeResult = StoreModel(modelDefs[j], out model, logger);
if (storeResult == true)
{
// Try to store animations for model as well
storeResult = StoreAnimations(ref model, logger);
}
if (storeResult == true)
{
if (models.ContainsKey(name) == false)
{
logger.Event("Adding model definition: " + name);
models.Add(name, model);
}
else
{
logger.Warning("Duplicate model definition: " + name);
}
}
}
catch (Exception e)
{
logger.Error("Unable to store model definition: " + name);
logger.Error(e.Message);
}
}
}
}
}
public bool Read(Logger logger)
{
bool result = true;
// Clear old data.
models.Clear();
skls.Clear();
skns.Clear();
textures.Clear();
inibins.Clear();
animationLists.Clear();
animations.Clear();
DirectoryInfo rootDir = null;
try
{
logger.Event("Reading models from: " + Root);
rootDir = new DirectoryInfo(Root);
}
catch
{
logger.Error("Unable to get the directory information: " + Root);
result = false;
}
//
// Try to find the raf files and read them.
//
if (result == true)
{
try
{
result = GetRAFFiles(rootDir, logger);
// If the finding or reading fails, bail.
if (!result)
{
logger.Error("Unable to find the 'filearchives' directory: " + Root);
}
}
catch (Exception e)
{
logger.Error("Unable to open directory: " + Root);
logger.Error(e.Message);
result = false;
}
}
// Sanity
if (result == true)
{
GenerateModelDefinitions(logger);
}
return result;
}