public override void AddAngles(VMFVector3Value angles)
{
foreach (VMFVector3Value vec in Vectors)
{
vec.AddAngles(angles);
}
}
public override void Rotate(VMFVector3Value angles)
{
foreach (VMFVector3Value vec in Vectors)
{
vec.Rotate(angles);
}
}
public override void Offset(VMFVector3Value vector)
{
foreach (VMFVector3Value vec in Vectors)
{
vec.Offset(vector);
}
}
public void VMMCollapse(string output)
{
Console.WriteLine("collapsing VMM");
// find the topLevel vmf
List <Dictionary <string, string> > topLevels = vmfs.FindAll(dic => dic.Keys.Contains("TopLevel"));
if (topLevels.Count == 0)
{
TopLevelVmf = vmfs.First();
}
else
{
TopLevelVmf = topLevels.Aggregate((curMin, x) => (curMin == null || int.Parse(x["TopLevel"]) < int.Parse(curMin["topLevel"]) ? x : curMin));
}
vmfs.Remove(TopLevelVmf);
//start file
VMFFile topmap = new VMFFile(vmfdir + "/" + TopLevelVmf["File"]);
VMFVector3Value originVal = new VMFVector3Value {
X = 0, Y = 0, Z = 0
};
VMFVector3Value anglesVal = new VMFVector3Value {
Pitch = 0, Roll = 0, Yaw = 0
};
VMFNumberValue fixup_styleVal = new VMFNumberValue {
Value = 0
};
foreach (Dictionary <string, string> vmf in vmfs)
{
Console.WriteLine("Inserting submap of {0}", vmfdir + "/" + vmf["File"]);
VMFFile submap = new VMFFile(vmfdir + "/" + vmf["File"]);
foreach (VMFStructure worldStruct in submap.World)
{
if (worldStruct.Type == VMFStructureType.Group || worldStruct.Type == VMFStructureType.Solid)
{
VMFStructure clone = worldStruct.Clone(topmap.LastID, topmap.LastNodeID);
clone.Transform(originVal, anglesVal);
topmap.World.Structures.Add(clone);
}
}
foreach (VMFStructure rootStruct in submap.Root)
{
if (rootStruct.Type == VMFStructureType.Entity)
{
VMFStructure clone = rootStruct.Clone(topmap.LastID, topmap.LastNodeID);
clone.Transform(originVal, anglesVal);
topmap.Root.Structures.Add(clone);
}
}
topmap.updateIds();
}
topmap.ResolveInstances();
topmap.Save(vmfdir + ".vmf");
}
public override void Rotate(VMFVector3Value angles)
{
double[ , ] mat = angles.RotationMatrix;
double x = X, y = Y, z = Z;
X = x * mat[0, 0] + y * mat[0, 1] + z * mat[0, 2];
Y = x * mat[1, 0] + y * mat[1, 1] + z * mat[1, 2];
Z = x * mat[2, 0] + y * mat[2, 1] + z * mat[2, 2];
}
public override void AddAngles(VMFVector3Value angles)
{
var a = CreateRotation(Pitch, Yaw, Roll);
var b = CreateRotation(angles.Pitch, angles.Yaw, angles.Roll);
double pitch, yaw, roll;
FindAngles(Mult(b, a), out pitch, out yaw, out roll);
Pitch = pitch;
Yaw = yaw;
Roll = roll;
}
public override void Rotate(VMFVector3Value angles)
{
Direction.Rotate(angles);
}
public override void Offset(VMFVector3Value vector)
{
Pan -= Direction.Dot(vector) / Scale;
}
public virtual void AddAngles(VMFVector3Value angles)
{
return;
}
public override void Offset(VMFVector3Value vector)
{
X += vector.X;
Y += vector.Y;
Z += vector.Z;
}
public double Dot(VMFVector3Value vector)
{
return(this.X * vector.X + this.Y * vector.Y + this.Z * vector.Z);
}
public virtual void Rotate(VMFVector3Value angles)
{
return;
}
public override void Rotate(VMFVector3Value angles)
{
Direction.Rotate(angles);
}
public override void Offset(VMFVector3Value vector)
{
Pan -= Direction.Dot(vector) / Scale;
}
public override void Offset(VMFVector3Value vector)
{
X += vector.X;
Y += vector.Y;
Z += vector.Z;
}
public virtual void AddAngles(VMFVector3Value angles)
{
return;
}
public override void Offset(VMFVector3Value vector)
{
foreach (VMFVector3Value vec in Vectors)
vec.Offset(vector);
}
public virtual void Offset(VMFVector3Value vector)
{
return;
}
public override void AddAngles(VMFVector3Value angles)
{
var a = CreateRotation(Pitch, Yaw, Roll);
var b = CreateRotation(angles.Pitch, angles.Yaw, angles.Roll);
double pitch, yaw, roll;
FindAngles(Mult(b, a), out pitch, out yaw, out roll);
Pitch = pitch;
Yaw = yaw;
Roll = roll;
}
public override void AddAngles(VMFVector3Value angles)
{
foreach (VMFVector3Value vec in Vectors)
vec.AddAngles(angles);
}
public void ResolveInstances()
{
Console.WriteLine("Resolving instances for " + OriginalPath + "...");
List <VMFStructure> structures = Root.Structures;
int autoName = 0;
for (int i = structures.Count - 1; i >= 0; --i)
{
VMFStructure structure = structures[i];
if (structure.Type == VMFStructureType.Entity)
{
VMFValue classnameVal = structure["classname"];
if (classnameVal != null)
{
switch (classnameVal.String)
{
case "func_instance":
structures.RemoveAt(i);
VMFStringValue fileVal = structure["file"] as VMFStringValue;
VMFVector3Value originVal = (structure["origin"] as VMFVector3Value) ?? new VMFVector3Value {
X = 0, Y = 0, Z = 0
};
VMFVector3Value anglesVal = (structure["angles"] as VMFVector3Value) ?? new VMFVector3Value {
Pitch = 0, Roll = 0, Yaw = 0
};
VMFNumberValue fixup_styleVal = (structure["fixup_style"] as VMFNumberValue) ?? new VMFNumberValue {
Value = 0
};
VMFValue targetnameVal = structure["targetname"];
Regex pattern = new Regex("^replace[0-9]*$");
List <KeyValuePair <String, String> > replacements = new List <KeyValuePair <String, String> >();
List <KeyValuePair <String, String> > matReplacements = new List <KeyValuePair <String, String> >();
foreach (KeyValuePair <String, VMFValue> keyVal in structure.Properties)
{
if (pattern.IsMatch(keyVal.Key))
{
String[] split = keyVal.Value.String.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (split.Length < 1)
{
continue;
}
if (split[0].StartsWith("#"))
{
matReplacements.Add(new KeyValuePair <String, String>(split[0].Substring(1).Trim(), keyVal.Value.String.Substring(split[0].Length + 1).Trim()));
continue;
}
if (!split[0].StartsWith("$"))
{
Console.WriteLine("Invalid property replacement name \"{0}\" - needs to begin with a $", split[0]);
continue;
}
replacements.Add(new KeyValuePair <String, String>(split[0].Trim(), keyVal.Value.String.Substring(split[0].Length + 1).Trim()));
}
}
replacements = replacements.OrderByDescending(x => x.Key.Length).ToList();
matReplacements = matReplacements.OrderByDescending(x => x.Key.Length).ToList();
TargetNameFixupStyle fixupStyle = (TargetNameFixupStyle)fixup_styleVal.Value;
String targetName = (targetnameVal != null ? targetnameVal.String : null);
if (fixupStyle != TargetNameFixupStyle.None && targetName == null)
{
targetName = "AutoInstance" + (autoName++);
}
if (fileVal == null)
{
Console.WriteLine("Invalid instance at (" + originVal.String + ")");
continue;
}
Console.WriteLine("Inserting instance of {0} at ({1}), ({2})", fileVal.String, originVal.String, anglesVal.String);
String file = fileVal.String;
VMFFile vmf = null;
if (stVMFCache.ContainsKey(file))
{
vmf = stVMFCache[file];
}
else
{
vmf = new VMFFile(file, Path.GetDirectoryName(OriginalPath));
if (vmf.Root != null)
{
vmf.ResolveInstances();
}
}
if (vmf.Root == null)
{
Console.WriteLine("Could not insert!");
continue;
}
foreach (VMFStructure worldStruct in vmf.World)
{
if (worldStruct.Type == VMFStructureType.Group || worldStruct.Type == VMFStructureType.Solid)
{
VMFStructure clone = worldStruct.Clone(LastID, LastNodeID, fixupStyle, targetName, replacements, matReplacements);
clone.Transform(originVal, anglesVal);
World.Structures.Add(clone);
}
}
int index = i;
foreach (VMFStructure rootStruct in vmf.Root)
{
if (rootStruct.Type == VMFStructureType.Entity)
{
VMFStructure clone = rootStruct.Clone(LastID, LastNodeID, fixupStyle, targetName, replacements, matReplacements);
clone.Transform(originVal, anglesVal);
Root.Structures.Insert(index++, clone);
}
}
LastID = Root.GetLastID();
LastNodeID = Root.GetLastNodeID();
break;
case "func_instance_parms":
structures.RemoveAt(i);
break;
}
}
}
}
Console.WriteLine("Instances resolved.");
}
public override void Rotate(VMFVector3Value angles)
{
foreach (VMFVector3Value vec in Vectors)
vec.Rotate(angles);
}
public virtual void Offset(VMFVector3Value vector)
{
return;
}
public double Dot(VMFVector3Value vector)
{
return this.X * vector.X + this.Y * vector.Y + this.Z * vector.Z;
}
public virtual void Rotate(VMFVector3Value angles)
{
return;
}
public override void Rotate(VMFVector3Value angles)
{
double[ , ] mat = angles.RotationMatrix;
double x = X, y = Y, z = Z;
X = x * mat[0, 0] + y * mat[0, 1] + z * mat[0, 2];
Y = x * mat[1, 0] + y * mat[1, 1] + z * mat[1, 2];
Z = x * mat[2, 0] + y * mat[2, 1] + z * mat[2, 2];
}
public void Transform(VMFVector3Value translation, VMFVector3Value rotation)
{
Dictionary <String, TransformType> transDict = null;
Dictionary <String, TransformType> entDict = null;
if (stTransformDict.ContainsKey(Type))
{
transDict = stTransformDict[Type];
}
if (Type == VMFStructureType.Entity)
{
String className = this["classname"].String;
if (className != null && stEntitiesDict.ContainsKey(className))
{
entDict = stEntitiesDict[className];
}
}
if (transDict != null || entDict != null)
{
foreach (KeyValuePair <String, VMFValue> keyVal in Properties)
{
TransformType trans = TransformType.None;
if (transDict != null)
{
foreach (String key in transDict.Keys)
{
if (Regex.IsMatch(keyVal.Key, key))
{
trans = transDict[key];
}
}
}
if (entDict != null && entDict.ContainsKey(keyVal.Key))
{
trans = entDict[keyVal.Key];
}
switch (trans)
{
case TransformType.Offset:
keyVal.Value.Rotate(rotation);
break;
case TransformType.Angle:
keyVal.Value.AddAngles(rotation);
break;
case TransformType.Position:
keyVal.Value.Rotate(rotation);
keyVal.Value.Offset(translation);
break;
}
}
}
foreach (VMFStructure structure in Structures)
{
structure.Transform(translation, rotation);
}
}
