public Dictionary <string, AnimationId> CollectAnimationIds(UserAvatar avatar)
{
Contract.Requires(avatar != null);
var userAnims = avatar.Assets
.Where(asset => AssetGroups.IsTypeInGroup(asset.Type, AssetGroup.Animations))
.ToDictionary(asset => Rbx2Source.GetEnumName(asset.Type).Replace("Animation", ""));
var animIds = new Dictionary <string, AnimationId>();
foreach (string animName in R15_ANIMATION_IDS.Keys)
{
AnimationId animId = new AnimationId();
if (userAnims.ContainsKey(animName))
{
animId.AnimationType = AnimationType.R15AnimFolder;
animId.AssetId = userAnims[animName].Id;
}
else
{
animId.AnimationType = AnimationType.KeyframeSequence;
animId.AssetId = R15_ANIMATION_IDS[animName];
}
animIds.Add(animName, animId);
}
if (userAnims.ContainsKey("Idle"))
{
// Remove default lookaround
if (animIds.ContainsKey("Idle2"))
{
animIds.Remove("Idle2");
}
// If this isn't rthro idle...
long animId = userAnims["Idle"].Id;
if (animId != 2510235063)
{
// Remove default pose
if (animIds.ContainsKey("Pose"))
{
animIds.Remove("Pose");
}
// Append the pose animation
AnimationId pose = new AnimationId()
{
AnimationType = AnimationType.R15AnimFolder,
AssetId = animId
};
animIds.Add("Pose", pose);
}
}
return(animIds);
}
public void SetGuide(string guideName, Rectangle guideSize, AvatarType avatarType)
{
string avatarTypeName = Rbx2Source.GetEnumName(avatarType);
string guidePath = "AvatarData/" + avatarType + "/Compositing/" + guideName + ".mesh";
Asset guideAsset = Asset.FromResource(guidePath);
Guide = Mesh.FromAsset(guideAsset);
Rect = guideSize;
}
public static void BuildAvatarGeometry(StudioMdlWriter meshBuilder, StudioBone bone)
{
Contract.Requires(meshBuilder != null && bone != null);
string task = "BuildGeometry_" + bone.Node.Name;
Rbx2Source.ScheduleTasks(task);
Node node = bone.Node;
BasePart part = bone.Part1;
bool isAvatarLimb = bone.IsAvatarBone;
string matName = part.Name;
if (isAvatarLimb)
{
BodyPart?limb = GetLimb(part);
if (!limb.HasValue)
{
throw new ArgumentException("Provided StudioBone did not point to a limb correctly.");
}
matName = Rbx2Source.GetEnumName(limb.Value);
}
var material = new ValveMaterial()
{
UseAvatarMap = isAvatarLimb
};
Rbx2Source.Print("Building Geometry for {0}", part.Name);
Rbx2Source.IncrementStack();
Mesh geometry = Mesh.BakePart(part, material);
meshBuilder.Materials[matName] = material;
for (int i = 0; i < geometry.NumFaces; i++)
{
Triangle tri = new Triangle()
{
Node = node,
FaceIndex = i,
Mesh = geometry,
Material = matName
};
meshBuilder.Triangles.Add(tri);
}
Rbx2Source.DecrementStack();
Rbx2Source.MarkTaskCompleted(task);
}
public static void BuildAvatarGeometry(StudioMdlWriter meshBuilder, Bone bone)
{
string task = "BuildGeometry_" + bone.Node.Name;
Rbx2Source.ScheduleTasks(task);
Node node = bone.Node;
Part part = bone.Part1;
bool IsAvatarLimb = bone.IsAvatarBone;
string materialName;
if (IsAvatarLimb)
{
Limb limb = GetLimb(part);
materialName = Rbx2Source.GetEnumName(limb);
}
else
{
materialName = part.Name;
}
Material material = new Material();
material.UseAvatarMap = IsAvatarLimb;
Rbx2Source.Print("Building Geometry for {0}", part.Name);
Rbx2Source.IncrementStack();
Mesh geometry = Mesh.BakePart(part, material);
if (!meshBuilder.Materials.ContainsKey(materialName))
{
meshBuilder.Materials.Add(materialName, material);
}
for (int i = 0; i < geometry.FaceCount; i++)
{
Triangle tri = new Triangle();
tri.Node = node;
tri.Mesh = geometry;
tri.FaceIndex = i;
tri.Material = materialName;
meshBuilder.Triangles.Add(tri);
}
Rbx2Source.DecrementStack();
Rbx2Source.MarkTaskCompleted(task);
}
public static void BuildAvatarGeometry(StudioMdlWriter meshBuilder, Bone bone)
{
string task = "BuildGeometry_" + bone.Node.Name;
Rbx2Source.ScheduleTasks(task);
Node node = bone.Node;
BasePart part = bone.Part1;
bool isAvatarLimb = bone.IsAvatarBone;
string matName = part.Name;
if (isAvatarLimb)
{
Limb limb = GetLimb(part);
matName = Rbx2Source.GetEnumName(limb);
}
Material material = new Material();
material.UseAvatarMap = isAvatarLimb;
Rbx2Source.Print("Building Geometry for {0}", part.Name);
Rbx2Source.IncrementStack();
Mesh geometry = Mesh.BakePart(part, material);
meshBuilder.Materials[matName] = material;
for (int i = 0; i < geometry.NumFaces; i++)
{
Triangle tri = new Triangle()
{
Node = node,
FaceIndex = i,
Mesh = geometry,
Material = matName
};
meshBuilder.Triangles.Add(tri);
}
Rbx2Source.DecrementStack();
Rbx2Source.MarkTaskCompleted(task);
}
public AssemblerData Assemble(UserAvatar avatar)
{
Contract.Requires(avatar != null);
UserInfo userInfo = avatar.UserInfo;
string userName = FileUtility.MakeNameWindowsSafe(userInfo.Username);
string appData = Environment.GetEnvironmentVariable("LocalAppData");
string rbx2Src = Path.Combine(appData, "Rbx2Source");
string avatars = Path.Combine(rbx2Src, "Avatars");
string userBin = Path.Combine(avatars, userName);
string modelDir = Path.Combine(userBin, "Model");
string anim8Dir = Path.Combine(modelDir, "Animations");
string texturesDir = Path.Combine(userBin, "Textures");
string materialsDir = Path.Combine(userBin, "Materials");
FileUtility.InitiateEmptyDirectories(modelDir, anim8Dir, texturesDir, materialsDir);
AvatarType avatarType = avatar.PlayerAvatarType;
ICharacterAssembler assembler;
if (avatarType == AvatarType.R15)
{
assembler = new R15CharacterAssembler();
}
else
{
assembler = new R6CharacterAssembler();
}
string compileDir = "roblox_avatars/" + userName;
string avatarTypeName = Rbx2Source.GetEnumName(avatarType);
Folder characterAssets = AppendCharacterAssets(avatar, avatarTypeName);
Rbx2Source.ScheduleTasks
(
"BuildCharacter",
"BuildCollisionModel",
"BuildAnimations",
"BuildTextures",
"BuildMaterials",
"BuildCompilerScript"
);
Rbx2Source.PrintHeader("BUILDING CHARACTER MODEL");
#region Build Character Model
///////////////////////////////////////////////////////////////////////////////////////////////////////
StudioMdlWriter writer = assembler.AssembleModel(characterAssets, avatar.Scales, DEBUG_RAPID_ASSEMBLY);
string studioMdl = writer.BuildFile();
string modelPath = Path.Combine(modelDir, "CharacterModel.smd");
FileUtility.WriteFile(modelPath, studioMdl);
string staticPose = writer.BuildFile(false);
string refPath = Path.Combine(modelDir, "ReferencePos.smd");
FileUtility.WriteFile(refPath, staticPose);
Rbx2Source.MarkTaskCompleted("BuildCharacter");
///////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("BUILDING COLLISION MODEL");
#region Build Character Collisions
///////////////////////////////////////////////////////////////////////////////////////////////////////
Folder collisionAssets = AppendCollisionAssets(avatar, avatarTypeName);
StudioMdlWriter collisionWriter = assembler.AssembleModel(collisionAssets, avatar.Scales, true);
string collisionModel = collisionWriter.BuildFile();
string cmodelPath = Path.Combine(modelDir, "CollisionModel.smd");
FileUtility.WriteFile(cmodelPath, collisionModel);
byte[] collisionJoints = assembler.CollisionModelScript;
string cjointsPath = Path.Combine(modelDir, "CollisionJoints.qc");
FileUtility.WriteFile(cjointsPath, collisionJoints);
Rbx2Source.MarkTaskCompleted("BuildCollisionModel");
///////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("BUILDING CHARACTER ANIMATIONS");
#region Build Character Animations
///////////////////////////////////////////////////////////////////////////////////////////////////////
var animIds = assembler.CollectAnimationIds(avatar);
var compileAnims = new Dictionary <string, Asset>();
if (animIds.Count > 0)
{
Rbx2Source.Print("Collecting Animations...");
Rbx2Source.IncrementStack();
Action <string, Asset> collectAnimation = (animName, animAsset) =>
{
if (!compileAnims.ContainsKey(animName))
{
Rbx2Source.Print("Collected animation {0} with id {1}", animName, animAsset.Id);
compileAnims.Add(animName, animAsset);
}
};
foreach (string animName in animIds.Keys)
{
var animId = animIds[animName];
var animAsset = animId.GetAsset();
var import = animAsset.OpenAsModel();
if (animId.AnimationType == AnimationType.R15AnimFolder)
{
Folder r15Anim = import.FindFirstChild <Folder>("R15Anim");
if (r15Anim != null)
{
foreach (Instance animDef in r15Anim.GetChildren())
{
if (animDef.Name == "idle")
{
var anims = animDef.GetChildrenOfType <Animation>();
if (anims.Length == 2)
{
var getLookAnim = anims.OrderBy((anim) =>
{
var weight = anim.FindFirstChild <NumberValue>("Weight");
if (weight != null)
{
return(weight.Value);
}
return(0.0);
});
var lookAnim = getLookAnim.First();
lookAnim.Destroy();
Asset lookAsset = Asset.GetByAssetId(lookAnim.AnimationId);
collectAnimation("Idle2", lookAsset);
}
}
Animation compileAnim = animDef.FindFirstChildOfClass <Animation>();
if (compileAnim != null)
{
Asset compileAsset = Asset.GetByAssetId(compileAnim.AnimationId);
string compileName = animName;
if (animDef.Name == "pose")
{
compileName = "Pose";
}
collectAnimation(compileName, compileAsset);
}
}
}
}
else
{
collectAnimation(animName, animAsset);
}
}
Rbx2Source.DecrementStack();
}
else
{
Rbx2Source.Print("No animations found :(");
}
if (compileAnims.Count > 0)
{
Rbx2Source.Print("Assembling Animations...");
Rbx2Source.IncrementStack();
foreach (string animName in compileAnims.Keys)
{
Rbx2Source.Print("Building Animation {0}...", animName);
Asset animAsset = compileAnims[animName];
var import = animAsset.OpenAsModel();
var sequence = import.FindFirstChildOfClass <KeyframeSequence>();
sequence.Name = animName;
var avatarTypeRef = new StringValue()
{
Value = $"{avatarType}",
Name = "AvatarType",
Parent = sequence
};
string animation = AnimationBuilder.Assemble(sequence, writer.Skeleton[0].Bones);
string animPath = Path.Combine(anim8Dir, animName + ".smd");
FileUtility.WriteFile(animPath, animation);
}
Rbx2Source.DecrementStack();
}
Rbx2Source.MarkTaskCompleted("BuildAnimations");
///////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("BUILDING CHARACTER TEXTURES");
#region Build Character Textures
///////////////////////////////////////////////////////////////////////////////////////////////////////
var materials = writer.Materials;
TextureBindings textures;
if (DEBUG_RAPID_ASSEMBLY)
{
textures = new TextureBindings();
materials.Clear();
}
else
{
TextureCompositor texCompositor = assembler.ComposeTextureMap(characterAssets, avatar.BodyColors);
textures = assembler.BindTextures(texCompositor, materials);
}
var images = textures.Images;
textures.MaterialDirectory = compileDir;
foreach (string imageName in images.Keys)
{
Rbx2Source.Print("Writing Image {0}.png", imageName);
Image image = images[imageName];
string imagePath = Path.Combine(texturesDir, imageName + ".png");
try
{
image.Save(imagePath, ImageFormat.Png);
}
catch
{
Rbx2Source.Print("IMAGE {0}.png FAILED TO SAVE!", imageName);
}
FileUtility.LockFile(imagePath);
}
CompositData.FreeAllocatedTextures();
Rbx2Source.MarkTaskCompleted("BuildTextures");
///////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("WRITING MATERIAL FILES");
#region Write Material Files
///////////////////////////////////////////////////////////////////////////////////////////////////////
var matLinks = textures.MatLinks;
foreach (string mtlName in matLinks.Keys)
{
Rbx2Source.Print("Building VMT {0}.vmt", mtlName);
string targetVtf = matLinks[mtlName];
string vmtPath = Path.Combine(materialsDir, mtlName + ".vmt");
ValveMaterial mtl = materials[mtlName];
mtl.SetVmtField("basetexture", "models/" + compileDir + "/" + targetVtf);
mtl.WriteVmtFile(vmtPath);
}
Rbx2Source.MarkTaskCompleted("BuildMaterials");
///////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("WRITING COMPILER SCRIPT");
#region Write Compiler Script
///////////////////////////////////////////////////////////////////////////////////////////////////////
string modelName = compileDir + ".mdl";
QuakeCWriter qc = new QuakeCWriter();
qc.Add("body", userName, "CharacterModel.smd");
qc.Add("modelname", modelName);
qc.Add("upaxis", "y");
// Compute the floor level of the avatar.
Folder assembly = characterAssets.FindFirstChild <Folder>("ASSEMBLY");
if (assembly != null)
{
float floor = ComputeFloorLevel(assembly);
string origin = "0 " + floor.ToInvariantString() + " 0";
qc.Add("origin", origin);
}
qc.Add("cdmaterials", "models/" + compileDir);
qc.Add("surfaceprop", "flesh");
qc.Add("include", "CollisionJoints.qc");
QuakeCItem refAnim = qc.Add("sequence", "reference", "ReferencePos.smd");
refAnim.AddSubItem("fps", 1);
refAnim.AddSubItem("loop");
foreach (string animName in compileAnims.Keys)
{
QuakeCItem sequence = qc.Add("sequence", animName.ToLowerInvariant(), "Animations/" + animName + ".smd");
sequence.AddSubItem("fps", AnimationBuilder.FrameRate);
if (avatarType == AvatarType.R6)
{
sequence.AddSubItem("delta");
}
sequence.AddSubItem("loop");
}
string qcFile = qc.ToString();
string qcPath = Path.Combine(modelDir, "Compile.qc");
FileUtility.WriteFile(qcPath, qcFile);
Rbx2Source.MarkTaskCompleted("BuildCompilerScript");
///////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
AssemblerData data = new AssemblerData()
{
ModelData = writer,
ModelName = modelName,
TextureData = textures,
CompilerScript = qcPath,
RootDirectory = userBin,
CompileDirectory = compileDir,
TextureDirectory = texturesDir,
MaterialDirectory = materialsDir,
};
return(data);
}
public TextureBindings BindTextures(TextureCompositor compositor, Dictionary <string, ValveMaterial> materials)
{
Contract.Requires(compositor != null && materials != null);
TextureBindings textures = new TextureBindings();
Bitmap core = compositor.BakeTextureMap();
Rbx2Source.SetDebugImage(core);
Bitmap head = TextureCompositor.CropBitmap(core, RECT_HEAD);
textures.BindTexture("Head", head);
Bitmap body = TextureCompositor.CropBitmap(core, RECT_BODY);
Folder characterAssets = compositor.CharacterAssets;
Rbx2Source.Print("Processing Package Textures...");
Rbx2Source.IncrementStack();
// Collect CharacterMeshes
var packagedLimbs = characterAssets
.GetChildrenOfType <CharacterMesh>()
.ToDictionary(mesh => mesh.BodyPart);
// Compose the textures that will be used
var limbOverlays = new Dictionary <BodyPart, long>();
var limbBitmaps = new Dictionary <long, Bitmap>()
{
{ 0, body }
};
foreach (BodyPart limb in LimbMatcher.Keys)
{
// Head is already textured, ignore it.
if (limb == BodyPart.Head)
{
continue;
}
// Is there a CharacterMesh for this limb?
if (packagedLimbs.ContainsKey(limb))
{
// Check the CharacterMesh textures.
CharacterMesh mesh = packagedLimbs[limb];
if (mesh.OverlayTextureId > 0)
{
// Use the overlay texture for this limb.
long overlayId = mesh.OverlayTextureId;
limbOverlays.Add(limb, overlayId);
// Compose this overlay texture with the body texture if it doesn't exist yet.
if (!limbBitmaps.ContainsKey(overlayId))
{
Asset overlayAsset = Asset.Get(overlayId);
TextureCompositor overlayCompositor = new TextureCompositor(AvatarType.R6, RECT_FULL);
overlayCompositor.SetContext("Overlay Texture " + overlayId);
overlayCompositor.AppendTexture(overlayAsset, RECT_BODY, 1);
overlayCompositor.AppendTexture(body, RECT_BODY);
Bitmap overlayTex = overlayCompositor.BakeTextureMap(RECT_BODY);
limbBitmaps.Add(overlayId, overlayTex);
}
continue;
}
else if (mesh.BaseTextureId > 0)
{
// Use the base texture for this limb.
long baseId = mesh.BaseTextureId;
limbOverlays.Add(limb, baseId);
// Compose the base texture if it doesn't exist yet.
if (!limbBitmaps.ContainsKey(baseId))
{
Asset baseAsset = Asset.Get(baseId);
TextureCompositor baseCompositor = new TextureCompositor(AvatarType.R6, RECT_FULL);
baseCompositor.SetContext("Base Texture " + baseId);
baseCompositor.AppendTexture(baseAsset, RECT_BODY);
Bitmap baseTex = baseCompositor.BakeTextureMap(RECT_BODY);
limbBitmaps.Add(baseId, baseTex);
}
continue;
}
}
// If no continue statement is reached, fallback to using the body texture.
// This occurs if the limb has no package, or the package limb has no textures.
limbOverlays.Add(limb, 0);
}
// Add the images into the texture assembly.
foreach (long id in limbBitmaps.Keys)
{
Bitmap bitmap = limbBitmaps[id];
string matName = GetBodyMatName(id);
textures.BindTexture(matName, bitmap, false);
}
// Link the limbs to their textures.
foreach (BodyPart limb in limbOverlays.Keys)
{
long id = limbOverlays[limb];
string matName = GetBodyMatName(id);
string limbName = Rbx2Source.GetEnumName(limb);
textures.BindTextureAlias(limbName, matName);
}
// Handle the rest of the materials
foreach (string matName in materials.Keys)
{
if (!textures.MatLinks.ContainsKey(matName))
{
ValveMaterial material = materials[matName];
Asset texture = material.TextureAsset;
TextureCompositor matComp = new TextureCompositor(AvatarType.R6, RECT_ITEM);
matComp.SetContext("Accessory Texture " + matName);
matComp.AppendTexture(texture, RECT_ITEM);
Bitmap bitmap = matComp.BakeTextureMap();
textures.BindTexture(matName, bitmap);
}
}
Rbx2Source.DecrementStack();
return(textures);
}
public AssemblerData Assemble(object metadata)
{
UserAvatar avatar = metadata as UserAvatar;
if (avatar == null)
{
throw new Exception("bad cast");
}
UserInfo userInfo = avatar.UserInfo;
string userName = FileUtility.MakeNameWindowsSafe(userInfo.Username);
string appData = Environment.GetEnvironmentVariable("AppData");
string rbx2Source = Path.Combine(appData, "Rbx2Source");
string avatars = Path.Combine(rbx2Source, "Avatars");
string userBin = Path.Combine(avatars, userName);
string modelDir = Path.Combine(userBin, "Model");
string animDir = Path.Combine(modelDir, "Animations");
string texturesDir = Path.Combine(userBin, "Textures");
string materialsDir = Path.Combine(userBin, "Materials");
FileUtility.InitiateEmptyDirectories(modelDir, animDir, texturesDir, materialsDir);
AvatarType avatarType = avatar.ResolvedAvatarType;
ICharacterAssembler assembler;
if (avatarType == AvatarType.R15)
{
assembler = new R15CharacterAssembler();
}
else
{
assembler = new R6CharacterAssembler();
}
string avatarTypeName = Rbx2Source.GetEnumName(avatar.ResolvedAvatarType);
Folder characterAssets = AppendCharacterAssets(avatar, avatarTypeName);
Rbx2Source.ScheduleTasks("BuildCharacter", "BuildCollisionModel", "BuildAnimations", "BuildTextures", "BuildMaterials", "BuildCompilerScript");
Rbx2Source.PrintHeader("BUILDING CHARACTER MODEL");
StudioMdlWriter writer = assembler.AssembleModel(characterAssets, avatar.Scales);
string studioMdl = writer.BuildFile();
string modelPath = Path.Combine(modelDir, "CharacterModel.smd");
FileUtility.WriteFile(modelPath, studioMdl);
// Clear the triangles so we can build a reference pose .smd file.
writer.Triangles.Clear();
string staticPose = writer.BuildFile();
string refPath = Path.Combine(modelDir, "ReferencePos.smd");
FileUtility.WriteFile(refPath, staticPose);
Rbx2Source.MarkTaskCompleted("BuildCharacter");
Rbx2Source.PrintHeader("BUILDING COLLISION MODEL");
Folder lowPoly = new Folder();
SpecialMesh lowPolyHead = new SpecialMesh();
lowPolyHead.MeshId = "rbxassetid://582002794";
lowPolyHead.MeshType = MeshType.FileMesh;
lowPolyHead.Scale = new Vector3(1, 1, 1);
lowPolyHead.Offset = new Vector3();
lowPolyHead.Parent = lowPoly;
StudioMdlWriter collisionWriter = assembler.AssembleModel(lowPoly, avatar.Scales);
string collisionModel = collisionWriter.BuildFile();
string cmodelPath = Path.Combine(modelDir, "CollisionModel.smd");
FileUtility.WriteFile(cmodelPath, collisionModel);
byte[] collisionJoints = assembler.CollisionModelScript;
string cjointsPath = Path.Combine(modelDir, "CollisionJoints.qc");
FileUtility.WriteFile(cjointsPath, collisionJoints);
Rbx2Source.MarkTaskCompleted("BuildCollisionModel");
Rbx2Source.PrintHeader("BUILDING CHARACTER ANIMATIONS");
Dictionary <string, string> animations = GatherAnimations(avatarType);
if (animations.Count > 0)
{
foreach (string animName in animations.Keys)
{
Rbx2Source.Print("Building Animation {0}", animName);
string localAnimPath = animations[animName];
Asset animAsset = Asset.FromResource(localAnimPath);
Folder import = RBXM.LoadFromAsset(animAsset);
KeyframeSequence sequence = import.FindFirstChildOfClass <KeyframeSequence>();
sequence.Name = animName;
sequence.AvatarType = avatarType;
string animation = AnimationAssembler.Assemble(sequence, writer.Skeleton[0].Bones);
string animPath = Path.Combine(animDir, animName + ".smd");
FileUtility.WriteFile(animPath, animation);
}
}
else
{
Rbx2Source.Print("No animations found :(");
}
Rbx2Source.MarkTaskCompleted("BuildAnimations");
Dictionary <string, Material> materials = writer.Materials;
Rbx2Source.PrintHeader("BUILDING CHARACTER TEXTURES");
string compileDirectory = "roblox_avatars/" + userName;
TextureCompositor texCompositor = assembler.ComposeTextureMap(characterAssets, avatar.BodyColors);
TextureAssembly texAssembly = assembler.AssembleTextures(texCompositor, materials);
CompositData.FreeAllocatedTextures();
texAssembly.MaterialDirectory = compileDirectory;
Dictionary <string, Image> images = texAssembly.Images;
foreach (string imageName in images.Keys)
{
Rbx2Source.Print("Writing Image {0}.png", imageName);
Image image = images[imageName];
string imagePath = Path.Combine(texturesDir, imageName + ".png");
try
{
image.Save(imagePath, ImageFormat.Png);
}
catch
{
Rbx2Source.Print("IMAGE {0}.png FAILED TO SAVE!", imageName);
}
FileUtility.LockFile(imagePath);
}
Rbx2Source.MarkTaskCompleted("BuildTextures");
Rbx2Source.PrintHeader("BUILDING MATERIAL FILES");
Dictionary <string, string> matLinks = texAssembly.MatLinks;
foreach (string mtlName in matLinks.Keys)
{
Rbx2Source.Print("Building VMT {0}.vmt", mtlName);
string targetVtf = matLinks[mtlName];
Material mtl = materials[mtlName];
ValveMaterial vmt = new ValveMaterial(mtl);
vmt.SetField("basetexture", "models/" + compileDirectory + "/" + targetVtf);
string vmtPath = Path.Combine(materialsDir, mtlName + ".vmt");
string vmtContent = vmt.ToString();
FileUtility.WriteFile(vmtPath, vmtContent);
}
Rbx2Source.MarkTaskCompleted("BuildMaterials");
Rbx2Source.PrintHeader("WRITING COMPILER SCRIPT");
QCWriter qc = new QCWriter();
QCommand model = new QCommand("body", userName, "CharacterModel.smd");
qc.AddCommand(model);
string modelNameStr = compileDirectory + ".mdl";
qc.WriteBasicCmd("modelname", modelNameStr);
qc.WriteBasicCmd("upaxis", "y");
string originStr = "";
if (avatarType == AvatarType.R6)
{
originStr = "0 -30 0";
}
else
{
originStr = "0 " + (-23.5 * avatar.Scales.Height).ToString(Rbx2Source.NormalParse) + " 0";
}
qc.WriteBasicCmd("origin", originStr, false);
qc.WriteBasicCmd("cdmaterials", "models/" + compileDirectory);
qc.WriteBasicCmd("surfaceprop", "flesh");
qc.WriteBasicCmd("include", "CollisionJoints.qc");
QCommand reference = new QCommand("sequence", "reference", "ReferencePos.smd");
reference.AddParameter("fps", "1");
reference.AddParameter("loop");
qc.AddCommand(reference);
foreach (string animName in animations.Keys)
{
QCommand sequence = new QCommand("sequence", animName.ToLower(), "Animations/" + animName + ".smd");
sequence.AddParameter("fps", AnimationAssembler.FrameRate.ToString());
sequence.AddParameter("loop");
if (avatarType == AvatarType.R6) // TODO: Find a work around so I can get rid of this.
{
sequence.AddParameter("delta");
}
qc.AddCommand(sequence);
}
string qcFile = qc.BuildFile();
string qcPath = Path.Combine(modelDir, "Compile.qc");
FileUtility.WriteFile(qcPath, qcFile);
Rbx2Source.MarkTaskCompleted("BuildCompilerScript");
AssemblerData data = new AssemblerData();
data.ModelData = writer;
data.TextureData = texAssembly;
data.CompilerScript = qcPath;
data.RootDirectory = userBin;
data.MaterialDirectory = materialsDir;
data.TextureDirectory = texturesDir;
data.CompileDirectory = compileDirectory;
data.ModelName = modelNameStr;
return(data);
}
public override string ToString()
{
return(Rbx2Source.GetEnumName(AnimationType) + ' ' + AssetId);
}