private void SerializeVector(IDataBlock block, RealQuaternion vec)
{
block.Writer.Write(vec.I);
block.Writer.Write(vec.J);
block.Writer.Write(vec.K);
block.Writer.Write(vec.W);
}
/// <summary>
/// Decompresses a position so that its components are in model space.
/// </summary>
/// <param name="pos">The position to decompress.</param>
/// <returns>The decompressed position.</returns>
public RealQuaternion DecompressPosition(RealQuaternion pos)
{
var newX = pos.I * _xScale + _info.X.Lower;
var newY = pos.J * _yScale + _info.Y.Lower;
var newZ = pos.K * _zScale + _info.Z.Lower;
return(new RealQuaternion(newX, newY, newZ, pos.W));
}
public static void Write(this BinaryWriter writer, RealQuaternion quat)
{
// Write a RealQuaternion object to the stream.
writer.Write(quat.x);
writer.Write(quat.y);
writer.Write(quat.z);
writer.Write(quat.w);
}
/// <summary>
/// Compresses a position so that its components are between 0 and 1.
/// </summary>
/// <param name="pos">The position to compress.</param>
/// <returns>The compressed position.</returns>
public RealQuaternion CompressPosition(RealQuaternion pos)
{
var newX = (pos.I - _info.X.Lower) / _xScale;
var newY = (pos.J - _info.Y.Lower) / _yScale;
var newZ = (pos.K - _info.Z.Lower) / _zScale;
return(new RealQuaternion(newX, newY, newZ, pos.W));
}
private RealQuaternion TransformTangent(RealQuaternion tangent)
{
return(new RealQuaternion(
(tangent.I * 2.0f) - 1.0f,
(tangent.J * 2.0f) - 1.0f,
(tangent.K * 2.0f) - 1.0f,
(tangent.W * 2.0f) - 1.0f));
}
public static RealQuaternion ReadRealQuaternion(this BinaryReader reader)
{
// Read a RealQuaternion object from the stream.
RealQuaternion quat = new RealQuaternion();
quat.x = reader.ReadSingle();
quat.y = reader.ReadSingle();
quat.z = reader.ReadSingle();
quat.w = reader.ReadSingle();
return(quat);
}
public void SetFieldValue(object owner, object value = null, object definition = null)
{
if (Loading || owner == null)
{
return;
}
if (value == null)
{
if (!float.TryParse(iTextBox.Text, out var i) ||
!float.TryParse(jTextBox.Text, out var j) ||
!float.TryParse(kTextBox.Text, out var k) ||
!float.TryParse(wTextBox.Text, out var w))
{
return;
}
value = new RealQuaternion(i, j, k, w);
}
Field.SetValue(owner, value);
}
public override object Execute(List <string> args)
{
foreach (var property in Definition.ShaderProperties)
{
RenderMethodTemplate template = null;
using (var cacheStream = Cache.OpenCacheRead())
template = Cache.Deserialize <RenderMethodTemplate>(cacheStream, property.Template);
for (var i = 0; i < template.RealParameterNames.Count; i++)
{
Console.WriteLine("");
var argumentName = Cache.StringTable.GetString(template.RealParameterNames[i].Name);
var argumentValue = new RealQuaternion(property.RealConstants[i].Values);
Console.WriteLine(string.Format("{0}:", argumentName));
if (argumentName.EndsWith("_map"))
{
Console.WriteLine(string.Format("\tX Scale: {0}", argumentValue.I));
Console.WriteLine(string.Format("\tY Scale: {0}", argumentValue.J));
Console.WriteLine(string.Format("\tX Offset: {0}", argumentValue.K));
Console.WriteLine(string.Format("\tY Offset: {0}", argumentValue.W));
}
else
{
Console.WriteLine(string.Format("\tX: {0}", argumentValue.I));
Console.WriteLine(string.Format("\tY: {0}", argumentValue.J));
Console.WriteLine(string.Format("\tZ: {0}", argumentValue.K));
Console.WriteLine(string.Format("\tW: {0}", argumentValue.W));
}
}
}
return(true);
}
public override object Execute(List <string> args)
{
if (args.Count < 2 || args.Count > 5)
{
return(false);
}
var argumentName = args[0];
var values = new List <float>();
while (args.Count > 1)
{
if (!float.TryParse(args[1], out var value))
{
throw new FormatException(args[1]);
}
values.Add(value);
args.RemoveAt(1);
}
RenderMethodTemplate template = null;
var properties = Definition.ShaderProperties[0];
using (var cacheStream = CacheContext.OpenTagCacheRead())
template = CacheContext.Deserialize <RenderMethodTemplate>(cacheStream, properties.Template);
var argumentIndex = -1;
for (var i = 0; i < template.VectorArguments.Count; i++)
{
if (CacheContext.GetString(template.VectorArguments[i].Name) == argumentName)
{
argumentIndex = i;
break;
}
}
if (argumentIndex < 0 || argumentIndex >= properties.Arguments.Count)
{
throw new KeyNotFoundException($"Invalid argument name: {argumentName}");
}
var argument = properties.Arguments[argumentIndex];
for (var i = 0; i < argument.Values.Length; i++)
{
if (i < values.Count)
{
argument.Values[i] = values[i];
}
else
{
argument.Values[i] = 0.0f;
}
}
var argumentValue = new RealQuaternion(argument.Values);
Console.WriteLine();
Console.WriteLine(string.Format("{0}:", argumentName));
if (argumentName.EndsWith("_map"))
{
Console.WriteLine(string.Format("\tX Scale: {0}", argumentValue.I));
Console.WriteLine(string.Format("\tY Scale: {0}", argumentValue.J));
Console.WriteLine(string.Format("\tX Offset: {0}", argumentValue.K));
Console.WriteLine(string.Format("\tY Offset: {0}", argumentValue.W));
}
else
{
Console.WriteLine(string.Format("\tX: {0}", argumentValue.I));
Console.WriteLine(string.Format("\tY: {0}", argumentValue.J));
Console.WriteLine(string.Format("\tZ: {0}", argumentValue.K));
Console.WriteLine(string.Format("\tW: {0}", argumentValue.W));
}
return(true);
}
public object ParseArgs(Type type, TagFieldInfo info, List <string> args)
{
var input = args[0];
object output = null;
if (type == typeof(byte))
{
if (args.Count != 1)
{
return(false);
}
if (!byte.TryParse(input, out byte value))
{
return(false);
}
output = value;
}
else if (type == typeof(sbyte))
{
if (args.Count != 1)
{
return(false);
}
if (!sbyte.TryParse(input, out sbyte value))
{
return(false);
}
output = value;
}
else if (type == typeof(short))
{
if (args.Count != 1)
{
return(false);
}
if (!short.TryParse(input, out short value))
{
return(false);
}
output = value;
}
else if (type == typeof(ushort))
{
if (args.Count != 1)
{
return(false);
}
if (!ushort.TryParse(input, out ushort value))
{
return(false);
}
output = value;
}
else if (type == typeof(int))
{
if (args.Count != 1)
{
return(false);
}
if (!int.TryParse(input, out int value))
{
return(false);
}
output = value;
}
else if (type == typeof(uint))
{
if (args.Count != 1)
{
return(false);
}
if (!uint.TryParse(input, out uint value))
{
return(false);
}
output = value;
}
else if (type == typeof(long))
{
if (args.Count != 1)
{
return(false);
}
if (!long.TryParse(input, out long value))
{
return(false);
}
output = value;
}
else if (type == typeof(ulong))
{
if (args.Count != 1)
{
return(false);
}
if (!ulong.TryParse(input, out ulong value))
{
return(false);
}
output = value;
}
else if (type == typeof(float))
{
if (args.Count != 1)
{
return(false);
}
if (!float.TryParse(input, out float value))
{
return(false);
}
output = value;
}
else if (type == typeof(string))
{
if (args.Count != 1)
{
return(false);
}
output = input;
}
else if (type == typeof(CachedTagInstance))
{
if (args.Count != 1 || !CacheContext.TryGetTag(input, out var tag))
{
return(false);
}
output = tag;
}
else if (type == typeof(Tag))
{
if (args.Count != 1)
{
return(false);
}
if (!CacheContext.TryParseGroupTag(args[0], out var result))
{
Console.WriteLine($"Invalid tag group specifier: {args[0]}");
return(false);
}
output = result;
}
else if (type == typeof(StringId))
{
if (args.Count != 1)
{
return(false);
}
output = CacheContext.GetStringId(input);
}
else if (type == typeof(Angle))
{
if (args.Count != 1)
{
return(false);
}
if (!float.TryParse(input, out float value))
{
return(false);
}
output = Angle.FromDegrees(value);
}
else if (type == typeof(RealEulerAngles2d))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float yaw) ||
!float.TryParse(args[1], out float pitch))
{
return(false);
}
output = new RealEulerAngles2d(
Angle.FromDegrees(yaw),
Angle.FromDegrees(pitch));
}
else if (type == typeof(RealEulerAngles3d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float yaw) ||
!float.TryParse(args[1], out float pitch) ||
!float.TryParse(args[2], out float roll))
{
return(false);
}
output = new RealEulerAngles3d(
Angle.FromDegrees(yaw),
Angle.FromDegrees(pitch),
Angle.FromDegrees(roll));
}
else if (type == typeof(RealPoint2d))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float x) ||
!float.TryParse(args[1], out float y))
{
return(false);
}
output = new RealPoint2d(x, y);
}
else if (type == typeof(RealPoint3d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float x) ||
!float.TryParse(args[1], out float y) ||
!float.TryParse(args[2], out float z))
{
return(false);
}
output = new RealPoint3d(x, y, z);
}
else if (type == typeof(RealVector2d))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j))
{
return(false);
}
output = new RealVector2d(i, j);
}
else if (type == typeof(RealVector3d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k))
{
return(false);
}
output = new RealVector3d(i, j, k);
}
else if (type == typeof(RealQuaternion))
{
if (args.Count != 4)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k) ||
!float.TryParse(args[3], out float w))
{
return(false);
}
output = new RealQuaternion(i, j, k, w);
}
else if (type == typeof(RealPlane2d))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float d))
{
return(false);
}
output = new RealPlane2d(i, j, d);
}
else if (type == typeof(RealPlane3d))
{
if (args.Count != 4)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k) ||
!float.TryParse(args[3], out float d))
{
return(false);
}
output = new RealPlane3d(i, j, k, d);
}
else if (type.IsEnum)
{
if (args.Count != 1)
{
return(false);
}
var query = args[0];
object found;
try
{
found = Enum.Parse(type, query);
}
catch
{
found = null;
}
var names = Enum.GetNames(type).ToList();
if (found == null)
{
var nameLow = query.ToLower();
var namesLow = names.Select(i => i.ToLower()).ToList();
found = namesLow.Find(n => n == nameLow);
if (found == null)
{
var nameSnake = query.ToSnakeCase();
var namesSnake = names.Select(i => i.ToSnakeCase()).ToList();
found = namesSnake.Find(n => n == nameSnake);
if (found == null)
{
Console.WriteLine("Invalid {0} enum option: {1}", type.Name, args[0]);
Console.WriteLine("");
Console.WriteLine("Valid options:");
foreach (var name in Enum.GetNames(type))
{
var fieldName = $"{type.FullName}.{name}".Replace("+", ".");
var documentationNode = EditTagContextFactory.Documentation.SelectSingleNode($"//member[starts-with(@name, 'F:{fieldName}')]");
Console.WriteLine("\t{0} {1}", name,
documentationNode != null ?
$":: {documentationNode.FirstChild.InnerText.Replace("\r\n", "").TrimStart().TrimEnd()}" :
"");
}
Console.WriteLine();
return(false);
}
else
{
found = Enum.Parse(type, names[namesSnake.IndexOf((string)found)]);
}
}
else
{
found = Enum.Parse(type, names[namesLow.IndexOf((string)found)]);
}
}
output = found;
}
else if (type == typeof(Bounds <>))
{
var rangeType = type.GenericTypeArguments[0];
var argCount = RangeArgCount(rangeType);
var min = ParseArgs(rangeType, null, args.Take(argCount).ToList());
if (min.Equals(false))
{
return(false);
}
var max = ParseArgs(rangeType, null, args.Skip(argCount).Take(argCount).ToList());
if (max.Equals(false))
{
return(false);
}
output = Activator.CreateInstance(type, new object[] { min, max });
}
else if (type.IsArray)
{
if (info?.FieldType == typeof(byte[]) && info?.Attribute.Length == 0)
{ // tag_data field
if (args.Count != 1)
{
return(false);
}
if (input.Length % 2 != 0)
{
return(false);
}
List <byte> bytes = new List <byte>();
for (int i = 0; i < input.Length; i = i + 2)
{
bytes.Add(Convert.ToByte(input.Substring(i, 2), 16));
}
output = bytes.ToArray();
}
else
{
if (info == null || args.Count != info.Attribute.Length)
{
return(false);
}
var elementType = info.FieldType.GetElementType();
var values = Array.CreateInstance(elementType, info.Attribute.Length);
for (var i = 0; i < info.Attribute.Length; i++)
{
values.SetValue(Convert.ChangeType(ParseArgs(elementType, null, new List <string> {
args[i]
}), elementType), i);
}
return(values);
}
}
else if (type == typeof(RealRgbColor))
{
if (args.Count != 3)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j) ||
!float.TryParse(args[2], out float k))
{
return(false);
}
output = new RealRgbColor(i, j, k);
}
else if (type == typeof(ArgbColor))
{
if (args.Count != 4)
{
return(false);
}
if (!byte.TryParse(args[0], out byte i) ||
!byte.TryParse(args[1], out byte j) ||
!byte.TryParse(args[2], out byte k) ||
!byte.TryParse(args[3], out byte w))
{
return(false);
}
output = new ArgbColor(i, j, k, w);
}
else if (type == typeof(Bounds <Angle>))
{
if (args.Count != 2)
{
return(false);
}
if (!float.TryParse(args[0], out float i) ||
!float.TryParse(args[1], out float j))
{
return(false);
}
output = new Bounds <Angle> {
Lower = Angle.FromDegrees(i), Upper = Angle.FromDegrees(j)
};
}
else if (type == typeof(PageableResource))
{
if (args.Count < 1 || args.Count > 2)
{
return(false);
}
if (args.Count == 1)
{
switch (args[0].ToLower())
{
case "null":
output = null;
break;
default:
output = new FileInfo(args[0]);
if (!((FileInfo)output).Exists)
{
throw new FileNotFoundException(args[0]);
}
break;
}
}
else if (args.Count == 2)
{
var resourceLocation = ResourceLocation.None;
switch (args[0].ToSnakeCase())
{
case "resources":
resourceLocation = ResourceLocation.Resources;
break;
case "textures":
resourceLocation = ResourceLocation.Textures;
break;
case "textures_b":
resourceLocation = ResourceLocation.TexturesB;
break;
case "audio":
resourceLocation = ResourceLocation.Audio;
break;
case "resources_b":
resourceLocation = ResourceLocation.ResourcesB;
break;
case "render_models" when CacheContext.Version >= CacheVersion.HaloOnline235640:
resourceLocation = ResourceLocation.RenderModels;
break;
case "lightmaps" when CacheContext.Version >= CacheVersion.HaloOnline235640:
resourceLocation = ResourceLocation.Lightmaps;
break;
default:
throw new FormatException($"Invalid resource location: {args[0]}");
}
var resourceFile = new FileInfo(args[1]);
if (!resourceFile.Exists)
{
throw new FileNotFoundException(args[1]);
}
output = (resourceLocation, resourceFile);
}
else
{
throw new NotImplementedException();
}
}
else
{
Console.WriteLine($"ERROR: Not Implemented.");
return(false);
// throw new NotImplementedException();
}
return(output);
}
private static Vector3D ToVector3D(RealQuaternion q)
{
return(new Vector3D(q.I, q.J, q.K));
}
/// <summary>
/// Convert H3 normal to HO normal for tinyposition vertex
/// </summary>
public RealQuaternion ConvertNormal(RealQuaternion normal)
{
return(new RealQuaternion(normal.ToArray().Select(e => ConvertToNormalBasis(e)).Reverse()));
}
private static RealQuaternion ConvertVectorSpace(RealQuaternion vector)
{
return(new RealQuaternion(ConvertVectorSpace(vector.I), ConvertVectorSpace(vector.J), ConvertVectorSpace(vector.K), vector.W));
}
public void WriteFloat4(RealQuaternion v)
{
Write(v.ToArray(), 4, e => Writer.Write(e));
}
public void WriteFloat16_4(RealQuaternion v)
{
Write(v.ToArray(), 4, e => Writer.Write(Half.GetBytes(new Half(e))));
}
public void WriteUShort4N(RealQuaternion v)
{
Write(v.ToArray(), 4, e => Writer.Write(NormalizeUShort(e)));
}
public void WriteUByte4N(RealQuaternion v)
{
Writer.Write(v.ToArray().Select(e => NormalizeByte(e)).ToArray());
}
public void WriteSByte4N(RealQuaternion v)
{
Writer.Write(v.ToArray().Select(e => unchecked ((byte)NormalizeSByte(e))).ToArray());
}
