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 TextureBindings BindTextures(TextureCompositor compositor, Dictionary <string, ValveMaterial> materials)
{
Contract.Requires(compositor != null && materials != null);
TextureBindings textureBinds = new TextureBindings();
Bitmap uvMap = compositor.BakeTextureMap();
Rbx2Source.SetDebugImage(uvMap);
foreach (string matName in materials.Keys)
{
Rbx2Source.Print("Building Material {0}", matName);
ValveMaterial material = materials[matName];
Image image = null;
if (material.UseAvatarMap)
{
if (Enum.TryParse(matName, out BodyPart limb))
{
Rectangle cropRegion = UVCrops[limb];
image = TextureCompositor.CropBitmap(uvMap, cropRegion);
}
}
else
{
Asset texture = material.TextureAsset;
if (texture != null)
{
byte[] textureData = texture.GetContent();
MemoryStream textureStream = new MemoryStream(textureData);
image = Image.FromStream(textureStream);
textureStream.Dispose();
}
}
textureBinds.BindTexture(matName, image);
}
return(textureBinds);
}
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 static StudioMdlWriter AssembleModel(Asset asset)
{
Contract.Requires(asset != null);
var content = asset.OpenAsModel();
Rbx2Source.ScheduleTasks("GatherParts", "BuildMesh");
List <BasePart> parts = new List <BasePart>();
AddParts(parts, content);
if (parts.Count == 0)
{
throw new Exception("No parts were found inside of this asset!");
}
BasePart primaryPart = null;
foreach (BasePart part in parts)
{
if (part is MeshPart || part.Name == "Handle")
{
primaryPart = part;
break;
}
}
if (primaryPart == null) // k lol
{
primaryPart = parts[0];
}
primaryPart.Name = asset.ProductInfo.WindowsSafeName.Trim();
// Mark the primaryPart's location as the center.
CFrame rootCoord = primaryPart.CFrame;
foreach (BasePart part in parts)
{
part.CFrame = rootCoord.ToObjectSpace(part.CFrame);
}
Rbx2Source.MarkTaskCompleted("GatherParts");
Rbx2Source.PrintHeader("BUILDING MESH");
StudioMdlWriter writer = new StudioMdlWriter();
BoneKeyframe skeleton = new BoneKeyframe();
writer.Skeleton.Add(skeleton);
List <StudioBone> bones = skeleton.Bones;
List <Node> nodes = writer.Nodes;
List <Triangle> triangles = writer.Triangles;
int numAssembledParts = 0;
var materials = writer.Materials;
var nameCounts = new Dictionary <string, int>();
foreach (BasePart part in parts)
{
// Make sure this part has a unique name.
string name = part.Name;
if (nameCounts.ContainsKey(name))
{
int count = ++nameCounts[name];
name += count.ToInvariantString();
part.Name = name;
}
else
{
nameCounts[name] = 0;
}
// Assemble the part.
var material = new ValveMaterial();
Mesh geometry = Mesh.BakePart(part, material);
if (geometry != null && geometry.NumFaces > 0)
{
string task = "BuildGeometry_" + name;
Rbx2Source.ScheduleTasks(task);
Rbx2Source.Print("Building Geometry for {0}", name);
var bone = new StudioBone(name, primaryPart, part)
{
C0 = part.CFrame
};
bones.Add(bone);
Node node = bone.Node;
nodes.Add(node);
int faceStride;
materials.Add(name, material);
if (geometry.HasLODs)
{
faceStride = geometry.LODs[1];
}
else
{
faceStride = geometry.NumFaces;
}
for (int i = 0; i < faceStride; i++)
{
Triangle tri = new Triangle()
{
Node = node,
Mesh = geometry,
FaceIndex = i,
Material = name,
};
triangles.Add(tri);
}
Rbx2Source.MarkTaskCompleted(task);
numAssembledParts++;
}
}
Rbx2Source.MarkTaskCompleted("BuildMesh");
return(writer);
}
public AssemblerData Assemble(long assetId)
{
Asset asset = Asset.Get(assetId);
string assetName = asset.ProductInfo.WindowsSafeName.Trim();
string appData = Environment.GetEnvironmentVariable("LocalAppData");
string rbx2Source = Path.Combine(appData, "Rbx2Source");
string items = Path.Combine(rbx2Source, "Items");
string rootDir = Path.Combine(items, assetName);
string modelDir = Path.Combine(rootDir, "Model");
string texturesDir = Path.Combine(rootDir, "Textures");
string materialsDir = Path.Combine(rootDir, "Materials");
FileUtility.InitiateEmptyDirectories(modelDir, texturesDir, materialsDir);
Rbx2Source.ScheduleTasks("BuildModel", "BuildTextures", "BuildMaterials", "BuildCompilerScript");
Rbx2Source.PrintHeader("BUILDING MODEL");
#region Build Model
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StudioMdlWriter writer = AssembleModel(asset);
string studioMdl = writer.BuildFile();
string modelPath = Path.Combine(modelDir, "Asset.smd");
FileUtility.WriteFile(modelPath, studioMdl);
string reference = writer.BuildFile(false);
string refPath = Path.Combine(modelDir, "Reference.smd");
FileUtility.WriteFile(refPath, reference);
Rbx2Source.MarkTaskCompleted("BuildModel");
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("BUILDING TEXTURES");
#region Build Textures
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materials = writer.Materials;
var textures = BindTextures(materials);
var images = textures.Images;
var compileDir = "roblox_assets/" + assetName;
foreach (string imageName in images.Keys)
{
Rbx2Source.Print("Writing Image {0}", 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);
}
textures.MaterialDirectory = compileDir;
Rbx2Source.MarkTaskCompleted("BuildTextures");
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
Rbx2Source.PrintHeader("WRITING MATERIAL FILES");
#region Write Materials
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
string mtlDir = "models/" + compileDir;
var matLinks = textures.MatLinks;
foreach (string matName in matLinks.Keys)
{
string vtfTarget = matLinks[matName];
string vmtPath = Path.Combine(materialsDir, matName + ".vmt");
ValveMaterial mat = materials[matName];
mat.SetVmtField("basetexture", mtlDir + '/' + vtfTarget);
mat.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", assetName, "Asset.smd");
qc.Add("modelname", modelName);
qc.Add("upaxis", "y");
qc.Add("cdmaterials", mtlDir);
QuakeCItem phys = qc.Add("collisionjoints", "Asset.smd");
phys.AddSubItem("$mass", 115.0);
phys.AddSubItem("$inertia", 2.00);
phys.AddSubItem("$damping", 0.01);
phys.AddSubItem("$rotdamping", 0.40);
QuakeCItem refAnim = qc.Add("sequence", "reference", "Reference.smd");
refAnim.AddSubItem("fps", 1);
refAnim.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 = rootDir,
CompileDirectory = compileDir,
TextureDirectory = texturesDir,
MaterialDirectory = materialsDir
};
return(data);
}
public static TextureBindings BindTextures(Dictionary <string, ValveMaterial> materials)
{
Contract.Requires(materials != null);
var textures = new TextureBindings();
var images = textures.Images;
foreach (string mtlName in materials.Keys)
{
ValveMaterial material = materials[mtlName];
Asset textureAsset = material.TextureAsset;
if (textureAsset == null || textureAsset.Id == 9854798)
{
var linkedTo = material.LinkedTo;
Color3 color;
if (linkedTo.BrickColor != null)
{
BrickColor bc = linkedTo.BrickColor;
color = bc.Color;
}
else if (linkedTo.Color3uint8 != null)
{
color = linkedTo.Color3uint8;
}
else
{
BrickColor def = BrickColor.FromNumber(-1);
color = def.Color;
}
float r = color.R,
g = color.G,
b = color.B;
if (!images.ContainsKey("BrickColor"))
{
byte[] rawImg = ResourceUtility.GetResource("Images/BlankWhite.png");
using (MemoryStream imgStream = new MemoryStream(rawImg))
{
Image image = Image.FromStream(imgStream);
textures.BindTexture("BrickColor", image, false);
}
}
material.UseEnvMap = true;
material.VertexColor = new Vector3(r, g, b);
textures.BindTextureAlias(mtlName, "BrickColor");
}
else
{
byte[] rawImg = textureAsset.GetContent();
using (MemoryStream imgStream = new MemoryStream(rawImg))
{
Image image = Image.FromStream(imgStream);
textures.BindTexture(mtlName, image);
}
}
}
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 AssemblerData Assemble(object metadata)
{
long assetId = (long)metadata;
Asset asset = Asset.Get(assetId);
string assetName = asset.ProductInfo.WindowsSafeName;
string appData = Environment.GetEnvironmentVariable("AppData");
string rbx2Source = Path.Combine(appData, "Rbx2Source");
string items = Path.Combine(rbx2Source, "Items");
string rootDir = Path.Combine(items, assetName);
string modelDir = Path.Combine(rootDir, "Model");
string texturesDir = Path.Combine(rootDir, "Textures");
string materialsDir = Path.Combine(rootDir, "Materials");
FileUtility.InitiateEmptyDirectories(modelDir, texturesDir, materialsDir);
Rbx2Source.ScheduleTasks("BuildModel", "BuildTextures", "BuildMaterials", "BuildCompilerScript");
// Build Model
StudioMdlWriter writer = AssembleModel(asset);
string studioMdl = writer.BuildFile();
string modelPath = Path.Combine(modelDir, "Asset.smd");
FileUtility.WriteFile(modelPath, studioMdl);
// Build Reference Sequence
Triangle[] triangles = writer.Triangles.ToArray();
writer.Triangles.Clear();
string reference = writer.BuildFile();
string refPath = Path.Combine(modelDir, "Reference.smd");
FileUtility.WriteFile(refPath, reference);
Rbx2Source.MarkTaskCompleted("BuildModel");
// Build Textures
Rbx2Source.PrintHeader("BUILDING TEXTURES");
Dictionary <string, Material> materials = writer.Materials;
string compileDirectory = "roblox_assets/" + assetName;
TextureAssembly texAssembly = AssembleTextures(materials);
texAssembly.MaterialDirectory = compileDirectory;
Dictionary <string, Image> images = texAssembly.Images;
foreach (string imageName in images.Keys)
{
Rbx2Source.Print("Writing Image {0}", 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");
// Build Materials
Rbx2Source.PrintHeader("BUILDING MATERIAL FILES");
string mtlDir = "models/" + compileDirectory;
Dictionary <string, string> matLinks = texAssembly.MatLinks;
Dictionary <string, Material> matLookup = new Dictionary <string, Material>();
foreach (string mtlName in matLinks.Keys)
{
Material mtl = materials[mtlName];
string vtfTarget = matLinks[mtlName];
string vmtPath = Path.Combine(materialsDir, mtlName + ".vmt");
if (!File.Exists(vmtPath))
{
Rbx2Source.Print("Building VMT {0}.vmt", mtlName);
ValveMaterial vmt = new ValveMaterial(mtl);
vmt.SetField("basetexture", mtlDir + "/" + vtfTarget);
string vmtContent = vmt.ToString();
FileUtility.WriteFile(vmtPath, vmtContent);
matLookup[mtlName] = mtl;
}
}
Rbx2Source.MarkTaskCompleted("BuildMaterials");
// Build Compiler Script
Rbx2Source.PrintHeader("WRITING COMPILER SCRIPT");
QCWriter qc = new QCWriter();
QCommand model = new QCommand("body", assetName, "Asset.smd");
qc.AddCommand(model);
string modelNameStr = compileDirectory + ".mdl";
qc.WriteBasicCmd("modelname", modelNameStr);
qc.WriteBasicCmd("upaxis", "y");
qc.WriteBasicCmd("cdmaterials", mtlDir);
QCommand collision = new QCommand("collisionjoints", "Asset.smd");
collision.AddParameter("$mass", 115.0);
collision.AddParameter("$inertia", 2.00);
collision.AddParameter("$damping", 0.01);
collision.AddParameter("$rotdamping", 0.40);
qc.AddCommand(collision);
QCommand sequence = new QCommand("sequence", "reference", "Reference.smd");
sequence.AddParameter("fps", 1);
sequence.AddParameter("loop");
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 = rootDir;
data.MaterialDirectory = materialsDir;
data.TextureDirectory = texturesDir;
data.CompileDirectory = compileDirectory;
data.ModelName = modelNameStr;
return(data);
}
