private void WriteKeyframeFloats_Float16(IList <EAN_Keyframe> keyframes, bool hasFirstKeyframe, bool hasFinalKeyframe, EAN_Keyframe defaultKeyframe)
{
if (!hasFirstKeyframe)
{
EAN_Keyframe defaultFirstKeyframe = (keyframes.Count == 0) ? defaultKeyframe : keyframes[0];
bytes.AddRange(Half.GetBytes((Half)defaultFirstKeyframe.X));
bytes.AddRange(Half.GetBytes((Half)defaultFirstKeyframe.Y));
bytes.AddRange(Half.GetBytes((Half)defaultFirstKeyframe.Z));
bytes.AddRange(Half.GetBytes((Half)defaultFirstKeyframe.W));
}
for (int i = 0; i < keyframes.Count; i++)
{
bytes.AddRange(Half.GetBytes((Half)keyframes[i].X));
bytes.AddRange(Half.GetBytes((Half)keyframes[i].Y));
bytes.AddRange(Half.GetBytes((Half)keyframes[i].Z));
bytes.AddRange(Half.GetBytes((Half)keyframes[i].W));
}
if (!hasFinalKeyframe)
{
EAN_Keyframe defaultFinalKeyframe = (keyframes.Count == 0) ? defaultKeyframe : keyframes[keyframes.Count - 1];
bytes.AddRange(Half.GetBytes((Half)defaultFinalKeyframe.X));
bytes.AddRange(Half.GetBytes((Half)defaultFinalKeyframe.Y));
bytes.AddRange(Half.GetBytes((Half)defaultFinalKeyframe.Z));
bytes.AddRange(Half.GetBytes((Half)defaultFinalKeyframe.W));
}
}
public void Write(Half value, Endianes endianes)
{
_tmp = Half.GetBytes(value);
if (endianes == Endianes.Little)
{
Array.Reverse(_tmp);
}
Write(_tmp);
}
public void GetBytesTest()
{
Half value = Half.ToHalf(0x1234);
byte[] expected = { 0x34, 0x12 };
byte[] actual = Half.GetBytes(value);
Assert.Equal(expected[0], actual[0]);
Assert.Equal(expected[1], actual[1]);
}
private void SetSignalRateLimit(Half LimitMCPS)
{
if (LimitMCPS < 0 || LimitMCPS > 511.99)
{
throw new ArgumentOutOfRangeException("MCPS Limit must be within 0 to 512.");
}
LimitMCPS *= (1 << 7);
byte[] Data = Half.GetBytes(LimitMCPS);
this.Bus.WriteRegister(this.Address, (byte)Registers.FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT, Data);
}
/// <summary>
/// Write UV Data to buffer. uvNum is either TexCoord 0, 1, 2, 7
/// </summary>
/// <param name="uvNum"></param>
/// <returns></returns>
public void WriteUvData(byte[] data, int i, int uvNum)
{
byte[] tempPosData;
//Do X
tempPosData = Half.GetBytes(UVs[uvNum].X);
Array.Copy(tempPosData, 0, data, i, 2);
//Do Y
UVs[uvNum].Y = -uvs[uvNum].Y;
tempPosData = Half.GetBytes(UVs[uvNum].Y);
Array.Copy(tempPosData, 0, data, i + 2, 2);
}
private void WriteKeyframeFloats_Float16(ObservableCollection <EAN_Keyframe> keyframes)
{
for (int i = 0; i < keyframes.Count(); i++)
{
int size = bytes.Count();
bytes.AddRange(Half.GetBytes((Half)keyframes[i].X));
bytes.AddRange(Half.GetBytes((Half)keyframes[i].Y));
bytes.AddRange(Half.GetBytes((Half)keyframes[i].Z));
bytes.AddRange(Half.GetBytes((Half)keyframes[i].W));
if (size + 8 != bytes.Count())
{
throw new Exception(String.Format("Assert Fail: Float16 struct is wrong size! (expected 8, was {0}).\nSave failed.", bytes.Count() - size));
}
}
}
public void SaveTextureAsKTX(RenderTexture rtex, String name, bool tile3D = false)
{
int texDepth = rtex.volumeDepth;
int texWidth = rtex.width;
int texHeight = rtex.height;
int floatSize = sizeof(float);
int channels = 4;
bool tileEnabled = tile3D && texDepth > 1;
if (tileEnabled)
{
texWidth *= texDepth;
texDepth = 1;
}
int texSize = texWidth * texHeight * texDepth;
ComputeBuffer buffer = new ComputeBuffer(texSize, floatSize * channels); // 4 bytes for float and 4 channels
CBUtility.ReadFromRenderTexture(rtex, channels, buffer, FrostbiteReadShader);
float[] data = new float[texSize * channels];
buffer.GetData(data);
Byte[] header =
{
0xAB, 0x4B, 0x54, 0x58, // first four bytes of Byte[12] identifier
0x20, 0x31, 0x31, 0xBB, // next four bytes of Byte[12] identifier
0x0D, 0x0A, 0x1A, 0x0A, // final four bytes of Byte[12] identifier
0x01, 0x02, 0x03, 0x04, // Byte[4] endianess (Big endian in this case)
};
FileStream fs = new FileStream("Assets/Textures/" + name + ".ktx", FileMode.OpenOrCreate);
BinaryWriter writer = new BinaryWriter(fs);
writer.Write(header);
UInt32 glType = 0x140B; // HALF
UInt32 glTypeSize = 2; // 2 bytes
UInt32 glFormat = 0x1908; // RGBA
UInt32 glInterformat = 0x881A; // RGBA FLOAT16
UInt32 glBaseInternalFormat = 0x1908; // RGBA
UInt32 width = (UInt32)texWidth;
UInt32 height = (UInt32)texHeight;
UInt32 depth = (UInt32)(texDepth == 1 ? 0 : texDepth);
UInt32 numOfArrElem = 0;
UInt32 numOfFace = 1;
UInt32 numOfMip = 1;
UInt32 bytesOfKeyVal = 0;
writer.Write(glType);
writer.Write(glTypeSize);
writer.Write(glFormat);
writer.Write(glInterformat);
writer.Write(glBaseInternalFormat);
writer.Write(width);
writer.Write(height);
writer.Write(depth);
writer.Write(numOfArrElem);
writer.Write(numOfFace);
writer.Write(numOfMip);
writer.Write(bytesOfKeyVal);
UInt32 imageSize = (UInt32)(texSize * channels * glTypeSize);
writer.Write(imageSize);
if (tileEnabled)
{
for (int j = 0; j < rtex.height; j++)
{
for (int k = 0; k < rtex.volumeDepth; k++)
{
for (int i = 0; i < rtex.width; i++)
{
int startIndex = k * rtex.width * rtex.height * channels + j * rtex.width * channels + i * channels;
writer.Write(Half.GetBytes((Half)data[startIndex]));
writer.Write(Half.GetBytes((Half)data[startIndex + 1]));
writer.Write(Half.GetBytes((Half)data[startIndex + 2]));
writer.Write(Half.GetBytes((Half)data[startIndex + 3]));
}
}
}
}
else
{
for (int i = 0; i < data.Length; ++i)
{
writer.Write(Half.GetBytes((Half)data[i]));
}
}
writer.Close();
fs.Close();
buffer.Release();
}
/// <summary>
/// Exports SkyParameters to an pcsp file.
/// </summary>
/// <param name="texture">The Unity Texture2D to export.</param>
/// <param name="exportPath">File path to export to.</param>
public static void ExportSkyParameters(UnityEngine.Texture2D texture, string exportPath)
{
Assert.IsTrue(texture.width == 128, "texture width must be equal to 128.");
Assert.IsTrue(texture.height == 64, "texture height must be equal to 64.");
Assert.IsNotNull(exportPath, "exportPath must not be null.");
FoxLib.Core.HalfColorRGBA[] precomputedSkyParameters = Utils.FoxUtils.UnityTexture2DToFoxHalfColorRGBA(texture, 0);
using (var writer = new BinaryWriter(new FileStream(exportPath, FileMode.Create)))
{
var writeFunction = new FoxLib.PrecomputedSkyParameters.WriteFunctions(new Action <Half>(half => writer.Write(Half.GetBytes(half))), writer.Write);
FoxLib.PrecomputedSkyParameters.Write(precomputedSkyParameters, writeFunction);
}
}
public List <byte> GetBytes(VTX_FLAGS flags)
{
List <byte> bytes = new List <byte>();
int size = 0;
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_POS))
{
bytes.AddRange(BitConverter.GetBytes(PositionX));
bytes.AddRange(BitConverter.GetBytes(PositionY));
bytes.AddRange(BitConverter.GetBytes(PositionZ));
size += 12;
}
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_NORM))
{
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
{
bytes.AddRange(Half.GetBytes((Half)NormalX));
bytes.AddRange(Half.GetBytes((Half)NormalY));
bytes.AddRange(Half.GetBytes((Half)NormalZ));
bytes.AddRange(new byte[2]);
size += 8;
}
else
{
bytes.AddRange(BitConverter.GetBytes(NormalX));
bytes.AddRange(BitConverter.GetBytes(NormalY));
bytes.AddRange(BitConverter.GetBytes(NormalZ));
size += 12;
}
}
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TANGENT))
{
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
{
bytes.AddRange(Half.GetBytes((Half)TangentX));
bytes.AddRange(Half.GetBytes((Half)TangentY));
bytes.AddRange(Half.GetBytes((Half)TangentZ));
bytes.AddRange(new byte[2]);
size += 8;
}
else
{
bytes.AddRange(BitConverter.GetBytes(TangentX));
bytes.AddRange(BitConverter.GetBytes(TangentY));
bytes.AddRange(BitConverter.GetBytes(TangentZ));
size += 12;
}
}
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TEX))
{
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
{
bytes.AddRange(Half.GetBytes((Half)TextureU));
bytes.AddRange(Half.GetBytes((Half)TextureV));
size += 4;
}
else
{
bytes.AddRange(BitConverter.GetBytes(TextureU));
bytes.AddRange(BitConverter.GetBytes(TextureV));
size += 8;
}
}
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TEX2))
{
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
{
bytes.AddRange(Half.GetBytes((Half)Texture2U));
bytes.AddRange(Half.GetBytes((Half)Texture2V));
size += 4;
}
else
{
bytes.AddRange(BitConverter.GetBytes(Texture2U));
bytes.AddRange(BitConverter.GetBytes(Texture2V));
size += 8;
}
}
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COLOR))
{
bytes.Add(ColorR);
bytes.Add(ColorG);
bytes.Add(ColorB);
bytes.Add(ColorA);
size += 4;
}
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_BLEND_WEIGHT))
{
bytes.Add(BlendIndexes[0]);
bytes.Add(BlendIndexes[1]);
bytes.Add(BlendIndexes[2]);
bytes.Add(BlendIndexes[3]);
size += 4;
if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
{
bytes.AddRange(Half.GetBytes((Half)BlendWeights[0]));
bytes.AddRange(Half.GetBytes((Half)BlendWeights[1]));
bytes.AddRange(Half.GetBytes((Half)BlendWeights[2]));
bytes.AddRange(Half.GetBytes((Half)0f));
size += 8; //An additional 2 bytes of padding added at the end
}
else
{
bytes.AddRange(BitConverter.GetBytes(BlendWeights[0]));
bytes.AddRange(BitConverter.GetBytes(BlendWeights[1]));
bytes.AddRange(BitConverter.GetBytes(BlendWeights[2]));
bytes.AddRange(BitConverter.GetBytes(0f));
size += 16;
}
}
if (size != bytes.Count)
{
throw new Exception(String.Format("EMD_Vertex size mismatch. Expected a size of {0}, but it was {1}. (Flags: {2})", size, bytes.Count, flags));
}
return(bytes);
}
public void WriteFloat16_4(RealQuaternion v)
{
Write(v.ToArray(), 4, e => Writer.Write(Half.GetBytes(new Half(e))));
}
public byte[] Write()
{
List <byte> bytes = new List <byte>();
int animCount = GetIndexedAnimationCount();
List <int> animNameOffsets = new List <int>();
//Header
bytes.AddRange(BitConverter.GetBytes(EMA_SIGNATURE));
bytes.AddRange(BitConverter.GetBytes((ushort)65534));
bytes.AddRange(BitConverter.GetBytes((ushort)32));
bytes.AddRange(BitConverter.GetBytes((int)Version));
bytes.AddRange(new byte[4]); //Skeleton offset
bytes.AddRange(BitConverter.GetBytes((ushort)animCount));
bytes.AddRange(BitConverter.GetBytes(I_18));
bytes.AddRange(BitConverter.GetBytes(I_20));
bytes.AddRange(BitConverter.GetBytes(I_24));
bytes.AddRange(BitConverter.GetBytes(I_28));
//Animation pointers
bytes.AddRange(new byte[4 * animCount]);
//Animations
foreach (var anim in Animations)
{
int animStartOffset = bytes.Count;
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), 32 + (anim.Index * 4));
List <float> values = anim.GetValues();
bytes.AddRange(BitConverter.GetBytes(anim.I_00));
bytes.AddRange(BitConverter.GetBytes((ushort)anim.CommandCount));
bytes.AddRange(BitConverter.GetBytes((int)values.Count));
bytes.AddRange(BitConverter.GetBytes((ushort)anim.I_08));
bytes.AddRange(BitConverter.GetBytes((ushort)anim.I_10));
animNameOffsets.Add(bytes.Count);
bytes.AddRange(new byte[4]); //Name offset
bytes.AddRange(new byte[4]); //value offset
bytes.AddRange(new byte[4 * anim.CommandCount]);
//Commands
for (int i = 0; i < anim.CommandCount; i++)
{
int startCommandOffset = bytes.Count;
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count - animStartOffset), animStartOffset + 20 + (i * 4));
anim.Commands[i].SetFlags(); //Calculate the known flags
if (HasSkeleton)
{
bytes.AddRange(BitConverter.GetBytes((ushort)GetBoneIndex(anim.Commands[i].BoneName)));
}
else
{
bytes.AddRange(new byte[2]);
}
bytes.Add(anim.Commands[i].I_02);
var bitArray_b = new BitArray(new bool[8] {
anim.Commands[i].I_03_b1, anim.Commands[i].I_03_b2_Int16ForTime, anim.Commands[i].I_03_b3_Int16ForValueIndex, anim.Commands[i].I_03_b4, false, false, false, false
});
var bitArray_a = new BitArray(new byte[1] {
anim.Commands[i].I_03_a
});
bitArray_a[3] = anim.Commands[i].I_03_a4;
bytes.Add((byte)Int4Converter.GetByte(Utils.ConvertToByte(bitArray_a), Utils.ConvertToByte(bitArray_b)));
bytes.AddRange(BitConverter.GetBytes((ushort)anim.Commands[i].KeyframeCount));
bytes.AddRange(new byte[2]);
//Sort keyframes
if (anim.Commands[i].KeyframeCount > 0)
{
var sortedList = anim.Commands[i].Keyframes.ToList();
sortedList.Sort((x, y) => x.Time - y.Time);
anim.Commands[i].Keyframes = new ObservableCollection <EMA_Keyframe>(sortedList);
}
//Write Time
for (int a = 0; a < anim.Commands[i].KeyframeCount; a++)
{
if (anim.Commands[i].I_03_b2_Int16ForTime)
{
bytes.AddRange(BitConverter.GetBytes(anim.Commands[i].Keyframes[a].Time));
}
else
{
bytes.Add((byte)anim.Commands[i].Keyframes[a].Time);
}
}
//Add padding
bytes.AddRange(new byte[Utils.CalculatePadding(bytes.Count - startCommandOffset, 4)]);
//Write value/index
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes((ushort)(bytes.Count - startCommandOffset)), startCommandOffset + 6);
for (int a = 0; a < anim.Commands[i].KeyframeCount; a++)
{
if (anim.Commands[i].I_03_b3_Int16ForValueIndex)
{
bytes.AddRange(BitConverter.GetBytes((ushort)anim.Commands[i].Keyframes[a].index));
bytes.AddRange(BitConverter.GetBytes((ushort)anim.Commands[i].Keyframes[a].Flags));
}
else
{
bytes.Add((byte)anim.Commands[i].Keyframes[a].index);
bytes.Add((byte)anim.Commands[i].Keyframes[a].Flags);
}
}
//Add padding
bytes.AddRange(new byte[Utils.CalculatePadding(bytes.Count - startCommandOffset, 4)]);
}
//Values
int valuesStartOffset = bytes.Count;
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count - animStartOffset), animStartOffset + 16);
foreach (var value in values)
{
if (anim.I_10 == ValueType.Float16)
{
bytes.AddRange(Half.GetBytes((Half)value));
}
else if (anim.I_10 == ValueType.Float32 || anim.I_10 == ValueType.Float32_2)
{
bytes.AddRange(BitConverter.GetBytes(value));
}
else
{
throw new InvalidDataException("Unknown ValueType. Cannot continue.");
}
}
bytes.AddRange(new byte[Utils.CalculatePadding(bytes.Count - valuesStartOffset, 4)]);
}
//Skeleton
if (HasSkeleton)
{
bytes.AddRange(new byte[Utils.CalculatePadding(bytes.Count, 16)]);
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count), 12);
bytes.AddRange(skeleton.Write());
}
//Strings (animations)
for (int i = 0; i < Animations.Count; i++)
{
if (!String.IsNullOrWhiteSpace(Animations[i].Name))
{
bytes = Utils.ReplaceRange(bytes, BitConverter.GetBytes(bytes.Count - animNameOffsets[i] + 12), animNameOffsets[i]);
bytes.AddRange(new byte[10]);
bytes.Add((byte)Animations[i].Name.Length);
bytes.AddRange(Encoding.ASCII.GetBytes(Animations[i].Name));
bytes.Add(0);
}
}
return(bytes.ToArray());
}
public void WriteFloat16_2(RealVector2d v)
{
Write(v.ToArray(), 2, e => Writer.Write(Half.GetBytes(new Half(e))));
}
public void WriteFloat16_4(Vector4 v)
{
Write(v.ToArray(), 4, e => _writer.Write(Half.GetBytes(new Half(e))));
}
private void SaveCloudTexAsKTX(int origWidth, int origHeight, int origDepth, float[] data, String name, bool tile3D)
{
int texWidth = origWidth;
int texHeight = origHeight;
int texDepth = origDepth;
int channels = 1;
bool tileEnabled = tile3D && texDepth > 1;
if (tileEnabled)
{
texWidth *= texDepth;
texDepth = 1;
}
int texSize = texWidth * texHeight * texDepth;
Byte[] header =
{
0xAB, 0x4B, 0x54, 0x58, // first four bytes of Byte[12] identifier
0x20, 0x31, 0x31, 0xBB, // next four bytes of Byte[12] identifier
0x0D, 0x0A, 0x1A, 0x0A, // final four bytes of Byte[12] identifier
0x01, 0x02, 0x03, 0x04, // Byte[4] endianess (Big endian in this case)
};
FileStream fs = new FileStream("Assets/Textures/" + name + ".ktx", FileMode.OpenOrCreate);
BinaryWriter writer = new BinaryWriter(fs);
writer.Write(header);
UInt32 glType = 0x140B; // HALF
UInt32 glTypeSize = 2; // 2 bytes
UInt32 glFormat = 0x1903; // RED
UInt32 glInterformat = 0x822D; // R_FLOAT16
UInt32 glBaseInternalFormat = 0x1903; // RED
UInt32 width = (UInt32)texWidth;
UInt32 height = (UInt32)texHeight;
UInt32 depth = (UInt32)(texDepth == 1 ? 0 : texDepth);
UInt32 numOfArrElem = 0;
UInt32 numOfFace = 1;
UInt32 numOfMip = 1;
UInt32 bytesOfKeyVal = 0;
writer.Write(glType);
writer.Write(glTypeSize);
writer.Write(glFormat);
writer.Write(glInterformat);
writer.Write(glBaseInternalFormat);
writer.Write(width);
writer.Write(height);
writer.Write(depth);
writer.Write(numOfArrElem);
writer.Write(numOfFace);
writer.Write(numOfMip);
writer.Write(bytesOfKeyVal);
UInt32 imageSize = (UInt32)(texSize * channels * glTypeSize);
writer.Write(imageSize);
if (tileEnabled)
{
for (int j = 0; j < origHeight; j++)
{
for (int k = 0; k < origDepth; k++)
{
for (int i = 0; i < origWidth; i++)
{
int startIndex = k * origWidth * origHeight * channels + j * origWidth * channels + i * channels;
writer.Write(Half.GetBytes((Half)data[startIndex]));
}
}
}
}
else
{
for (int i = 0; i < data.Length; ++i)
{
writer.Write(Half.GetBytes((Half)data[i]));
}
}
writer.Close();
fs.Close();
}
private static byte[] GetHalfBytes_(float value)
{
var half = new Half(value);
return(Half.GetBytes(half));
}
public byte[] SetFreqValueMessage(float freqValue)
{
var floatToByte = Half.GetBytes((Half)freqValue).Reverse().ToArray();
return(GetWriteRegisterMessage(BedFreqPosition, floatToByte));
}
public byte[] SetMaxAngleValueMessage(float maxAngleValue)
{
var floatToByte = Half.GetBytes((Half)maxAngleValue).Reverse().ToArray();
return(GetWriteRegisterMessage(BedMaxAnglePosition, floatToByte));
}
