clockwerk-opensim-stable – Rev 1
?pathlinks?
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.IO;
using OpenMetaverse;
namespace OpenSim.Region.Framework.Scenes.Animation
{
/// <summary>
/// Written to decode and encode a binary animation asset.
/// The SecondLife Client reads in a BVH file and converts
/// it to the format described here. This isn't
/// </summary>
public class BinBVHAnimation
{
/// <summary>
/// Rotation Keyframe count (used internally)
/// Don't use this, use the rotationkeys.Length on each joint
/// </summary>
private int rotationkeys;
/// <summary>
/// Position Keyframe count (used internally)
/// Don't use this, use the positionkeys.Length on each joint
/// </summary>
private int positionkeys;
public UInt16 unknown0; // Always 1
public UInt16 unknown1; // Always 0
/// <summary>
/// Animation Priority
/// </summary>
public int Priority;
/// <summary>
/// The animation length in seconds.
/// </summary>
public Single Length;
/// <summary>
/// Expression set in the client. Null if [None] is selected
/// </summary>
public string ExpressionName; // "" (null)
/// <summary>
/// The time in seconds to start the animation
/// </summary>
public Single InPoint;
/// <summary>
/// The time in seconds to end the animation
/// </summary>
public Single OutPoint;
/// <summary>
/// Loop the animation
/// </summary>
public bool Loop;
/// <summary>
/// Meta data. Ease in Seconds.
/// </summary>
public Single EaseInTime;
/// <summary>
/// Meta data. Ease out seconds.
/// </summary>
public Single EaseOutTime;
/// <summary>
/// Meta Data for the Hand Pose
/// </summary>
public uint HandPose;
/// <summary>
/// Number of joints defined in the animation
/// Don't use this.. use joints.Length
/// </summary>
private uint m_jointCount;
/// <summary>
/// Contains an array of joints
/// </summary>
public binBVHJoint[] Joints;
public byte[] ToBytes()
{
byte[] outputbytes = new byte[0];
BinaryWriter iostream = new BinaryWriter(new MemoryStream());
iostream.Write(BinBVHUtil.ES(Utils.UInt16ToBytes(unknown0)));
iostream.Write(BinBVHUtil.ES(Utils.UInt16ToBytes(unknown1)));
iostream.Write(BinBVHUtil.ES(Utils.IntToBytes(Priority)));
iostream.Write(BinBVHUtil.ES(Utils.FloatToBytes(Length)));
iostream.Write(BinBVHUtil.WriteNullTerminatedString(ExpressionName));
iostream.Write(BinBVHUtil.ES(Utils.FloatToBytes(InPoint)));
iostream.Write(BinBVHUtil.ES(Utils.FloatToBytes(OutPoint)));
iostream.Write(BinBVHUtil.ES(Utils.IntToBytes(Loop ? 1 : 0)));
iostream.Write(BinBVHUtil.ES(Utils.FloatToBytes(EaseInTime)));
iostream.Write(BinBVHUtil.ES(Utils.FloatToBytes(EaseOutTime)));
iostream.Write(BinBVHUtil.ES(Utils.UIntToBytes(HandPose)));
iostream.Write(BinBVHUtil.ES(Utils.UIntToBytes((uint)(Joints.Length))));
for (int i = 0; i < Joints.Length; i++)
{
Joints[i].WriteBytesToStream(iostream, InPoint, OutPoint);
}
iostream.Write(BinBVHUtil.ES(Utils.IntToBytes(0)));
MemoryStream ms = (MemoryStream)iostream.BaseStream;
outputbytes = ms.ToArray();
ms.Close();
iostream.Close();
return outputbytes;
}
public BinBVHAnimation()
{
rotationkeys = 0;
positionkeys = 0;
unknown0 = 1;
unknown1 = 0;
Priority = 1;
Length = 0;
ExpressionName = string.Empty;
InPoint = 0;
OutPoint = 0;
Loop = false;
EaseInTime = 0;
EaseOutTime = 0;
HandPose = 1;
m_jointCount = 0;
Joints = new binBVHJoint[1];
Joints[0] = new binBVHJoint();
Joints[0].Name = "mPelvis";
Joints[0].Priority = 7;
Joints[0].positionkeys = new binBVHJointKey[1];
Joints[0].rotationkeys = new binBVHJointKey[1];
Random rnd = new Random();
Joints[0].rotationkeys[0] = new binBVHJointKey();
Joints[0].rotationkeys[0].time = (0f);
Joints[0].rotationkeys[0].key_element.X = ((float)rnd.NextDouble() * 2 - 1);
Joints[0].rotationkeys[0].key_element.Y = ((float)rnd.NextDouble() * 2 - 1);
Joints[0].rotationkeys[0].key_element.Z = ((float)rnd.NextDouble() * 2 - 1);
Joints[0].positionkeys[0] = new binBVHJointKey();
Joints[0].positionkeys[0].time = (0f);
Joints[0].positionkeys[0].key_element.X = ((float)rnd.NextDouble() * 2 - 1);
Joints[0].positionkeys[0].key_element.Y = ((float)rnd.NextDouble() * 2 - 1);
Joints[0].positionkeys[0].key_element.Z = ((float)rnd.NextDouble() * 2 - 1);
}
public BinBVHAnimation(byte[] animationdata)
{
int i = 0;
if (!BitConverter.IsLittleEndian)
{
unknown0 = Utils.BytesToUInt16(BinBVHUtil.EndianSwap(animationdata,i,2)); i += 2; // Always 1
unknown1 = Utils.BytesToUInt16(BinBVHUtil.EndianSwap(animationdata, i, 2)); i += 2; // Always 0
Priority = Utils.BytesToInt(BinBVHUtil.EndianSwap(animationdata, i, 4)); i += 4;
Length = Utils.BytesToFloat(BinBVHUtil.EndianSwap(animationdata, i, 4), 0); i += 4;
}
else
{
unknown0 = Utils.BytesToUInt16(animationdata, i); i += 2; // Always 1
unknown1 = Utils.BytesToUInt16(animationdata, i); i += 2; // Always 0
Priority = Utils.BytesToInt(animationdata, i); i += 4;
Length = Utils.BytesToFloat(animationdata, i); i += 4;
}
ExpressionName = ReadBytesUntilNull(animationdata, ref i);
if (!BitConverter.IsLittleEndian)
{
InPoint = Utils.BytesToFloat(BinBVHUtil.EndianSwap(animationdata, i, 4), 0); i += 4;
OutPoint = Utils.BytesToFloat(BinBVHUtil.EndianSwap(animationdata, i, 4), 0); i += 4;
Loop = (Utils.BytesToInt(BinBVHUtil.EndianSwap(animationdata, i, 4)) != 0); i += 4;
EaseInTime = Utils.BytesToFloat(BinBVHUtil.EndianSwap(animationdata, i, 4), 0); i += 4;
EaseOutTime = Utils.BytesToFloat(BinBVHUtil.EndianSwap(animationdata, i, 4), 0); i += 4;
HandPose = Utils.BytesToUInt(BinBVHUtil.EndianSwap(animationdata, i, 4)); i += 4; // Handpose?
m_jointCount = Utils.BytesToUInt(animationdata, i); i += 4; // Get Joint count
}
else
{
InPoint = Utils.BytesToFloat(animationdata, i); i += 4;
OutPoint = Utils.BytesToFloat(animationdata, i); i += 4;
Loop = (Utils.BytesToInt(animationdata, i) != 0); i += 4;
EaseInTime = Utils.BytesToFloat(animationdata, i); i += 4;
EaseOutTime = Utils.BytesToFloat(animationdata, i); i += 4;
HandPose = Utils.BytesToUInt(animationdata, i); i += 4; // Handpose?
m_jointCount = Utils.BytesToUInt(animationdata, i); i += 4; // Get Joint count
}
Joints = new binBVHJoint[m_jointCount];
// deserialize the number of joints in the animation.
// Joints are variable length blocks of binary data consisting of joint data and keyframes
for (int iter = 0; iter < m_jointCount; iter++)
{
binBVHJoint joint = readJoint(animationdata, ref i);
Joints[iter] = joint;
}
}
/// <summary>
/// Variable length strings seem to be null terminated in the animation asset.. but..
/// use with caution, home grown.
/// advances the index.
/// </summary>
/// <param name="data">The animation asset byte array</param>
/// <param name="i">The offset to start reading</param>
/// <returns>a string</returns>
private static string ReadBytesUntilNull(byte[] data, ref int i)
{
char nterm = '\0'; // Null terminator
int endpos = i;
int startpos = i;
// Find the null character
for (int j = i; j < data.Length; j++)
{
char spot = Convert.ToChar(data[j]);
if (spot == nterm)
{
endpos = j;
break;
}
}
// if we got to the end, then it's a zero length string
if (i == endpos)
{
// advance the 1 null character
i++;
return string.Empty;
}
else
{
// We found the end of the string
// append the bytes from the beginning of the string to the end of the string
// advance i
byte[] interm = new byte[endpos-i];
for (; i<endpos; i++)
{
interm[i-startpos] = data[i];
}
i++; // advance past the null character
return Utils.BytesToString(interm);
}
}
/// <summary>
/// Read in a Joint from an animation asset byte array
/// Variable length Joint fields, yay!
/// Advances the index
/// </summary>
/// <param name="data">animation asset byte array</param>
/// <param name="i">Byte Offset of the start of the joint</param>
/// <returns>The Joint data serialized into the binBVHJoint structure</returns>
private binBVHJoint readJoint(byte[] data, ref int i)
{
binBVHJointKey[] positions;
binBVHJointKey[] rotations;
binBVHJoint pJoint = new binBVHJoint();
/*
109
84
111
114
114
111
0 <--- Null terminator
*/
pJoint.Name = ReadBytesUntilNull(data, ref i); // Joint name
/*
2 <- Priority Revisited
0
0
0
*/
/*
5 <-- 5 keyframes
0
0
0
... 5 Keyframe data blocks
*/
/*
2 <-- 2 keyframes
0
0
0
.. 2 Keyframe data blocks
*/
if (!BitConverter.IsLittleEndian)
{
pJoint.Priority = Utils.BytesToInt(BinBVHUtil.EndianSwap(data, i, 4)); i += 4; // Joint Priority override?
rotationkeys = Utils.BytesToInt(BinBVHUtil.EndianSwap(data, i, 4)); i += 4; // How many rotation keyframes
}
else
{
pJoint.Priority = Utils.BytesToInt(data, i); i += 4; // Joint Priority override?
rotationkeys = Utils.BytesToInt(data, i); i += 4; // How many rotation keyframes
}
// argh! floats into two bytes!.. bad bad bad bad
// After fighting with it for a while.. -1, to 1 seems to give the best results
rotations = readKeys(data, ref i, rotationkeys, -1f, 1f);
for (int iter = 0; iter < rotations.Length; iter++)
{
rotations[iter].W = 1f -
(rotations[iter].key_element.X + rotations[iter].key_element.Y +
rotations[iter].key_element.Z);
}
if (!BitConverter.IsLittleEndian)
{
positionkeys = Utils.BytesToInt(BinBVHUtil.EndianSwap(data, i, 4)); i += 4; // How many position keyframes
}
else
{
positionkeys = Utils.BytesToInt(data, i); i += 4; // How many position keyframes
}
// Read in position keyframes
// argh! more floats into two bytes!.. *head desk*
// After fighting with it for a while.. -5, to 5 seems to give the best results
positions = readKeys(data, ref i, positionkeys, -5f, 5f);
pJoint.rotationkeys = rotations;
pJoint.positionkeys = positions;
return pJoint;
}
/// <summary>
/// Read Keyframes of a certain type
/// advance i
/// </summary>
/// <param name="data">Animation Byte array</param>
/// <param name="i">Offset in the Byte Array. Will be advanced</param>
/// <param name="keycount">Number of Keyframes</param>
/// <param name="min">Scaling Min to pass to the Uint16ToFloat method</param>
/// <param name="max">Scaling Max to pass to the Uint16ToFloat method</param>
/// <returns></returns>
private binBVHJointKey[] readKeys(byte[] data, ref int i, int keycount, float min, float max)
{
float x;
float y;
float z;
/*
0.o, Float values in Two bytes.. this is just wrong >:(
17 255 <-- Time Code
17 255 <-- Time Code
255 255 <-- X
127 127 <-- X
255 255 <-- Y
127 127 <-- Y
213 213 <-- Z
142 142 <---Z
*/
binBVHJointKey[] m_keys = new binBVHJointKey[keycount];
for (int j = 0; j < keycount; j++)
{
binBVHJointKey pJKey = new binBVHJointKey();
if (!BitConverter.IsLittleEndian)
{
pJKey.time = Utils.UInt16ToFloat(BinBVHUtil.EndianSwap(data, i, 2), 0, InPoint, OutPoint); i += 2;
x = Utils.UInt16ToFloat(BinBVHUtil.EndianSwap(data, i, 2), 0, min, max); i += 2;
y = Utils.UInt16ToFloat(BinBVHUtil.EndianSwap(data, i, 2), 0, min, max); i += 2;
z = Utils.UInt16ToFloat(BinBVHUtil.EndianSwap(data, i, 2), 0, min, max); i += 2;
}
else
{
pJKey.time = Utils.UInt16ToFloat(data, i, InPoint, OutPoint); i += 2;
x = Utils.UInt16ToFloat(data, i, min, max); i += 2;
y = Utils.UInt16ToFloat(data, i, min, max); i += 2;
z = Utils.UInt16ToFloat(data, i, min, max); i += 2;
}
pJKey.key_element = new Vector3(x, y, z);
m_keys[j] = pJKey;
}
return m_keys;
}
}
/// <summary>
/// A Joint and it's associated meta data and keyframes
/// </summary>
public struct binBVHJoint
{
/// <summary>
/// Name of the Joint. Matches the avatar_skeleton.xml in client distros
/// </summary>
public string Name;
/// <summary>
/// Joint Animation Override? Was the same as the Priority in testing..
/// </summary>
public int Priority;
/// <summary>
/// Array of Rotation Keyframes in order from earliest to latest
/// </summary>
public binBVHJointKey[] rotationkeys;
/// <summary>
/// Array of Position Keyframes in order from earliest to latest
/// This seems to only be for the Pelvis?
/// </summary>
public binBVHJointKey[] positionkeys;
public void WriteBytesToStream(BinaryWriter iostream, float InPoint, float OutPoint)
{
iostream.Write(BinBVHUtil.WriteNullTerminatedString(Name));
iostream.Write(BinBVHUtil.ES(Utils.IntToBytes(Priority)));
iostream.Write(BinBVHUtil.ES(Utils.IntToBytes(rotationkeys.Length)));
for (int i=0;i<rotationkeys.Length;i++)
{
rotationkeys[i].WriteBytesToStream(iostream, InPoint, OutPoint, -1f, 1f);
}
iostream.Write(BinBVHUtil.ES(Utils.IntToBytes((positionkeys.Length))));
for (int i = 0; i < positionkeys.Length; i++)
{
positionkeys[i].WriteBytesToStream(iostream, InPoint, OutPoint, -256f, 256f);
}
}
}
/// <summary>
/// A Joint Keyframe. This is either a position or a rotation.
/// </summary>
public struct binBVHJointKey
{
// Time in seconds for this keyframe.
public float time;
/// <summary>
/// Either a Vector3 position or a Vector3 Euler rotation
/// </summary>
public Vector3 key_element;
public float W;
public void WriteBytesToStream(BinaryWriter iostream, float InPoint, float OutPoint, float min, float max)
{
iostream.Write(BinBVHUtil.ES(Utils.UInt16ToBytes(BinBVHUtil.FloatToUInt16(time, InPoint, OutPoint))));
iostream.Write(BinBVHUtil.ES(Utils.UInt16ToBytes(BinBVHUtil.FloatToUInt16(key_element.X, min, max))));
iostream.Write(BinBVHUtil.ES(Utils.UInt16ToBytes(BinBVHUtil.FloatToUInt16(key_element.Y, min, max))));
iostream.Write(BinBVHUtil.ES(Utils.UInt16ToBytes(BinBVHUtil.FloatToUInt16(key_element.Z, min, max))));
}
}
/// <summary>
/// Poses set in the animation metadata for the hands.
/// </summary>
public enum HandPose : uint
{
Spread = 0,
Relaxed = 1,
Point_Both = 2,
Fist = 3,
Relaxed_Left = 4,
Point_Left = 5,
Fist_Left = 6,
Relaxed_Right = 7,
Point_Right = 8,
Fist_Right = 9,
Salute_Right = 10,
Typing = 11,
Peace_Right = 12
}
public static class BinBVHUtil
{
public const float ONE_OVER_U16_MAX = 1.0f / UInt16.MaxValue;
public static UInt16 FloatToUInt16(float val, float lower, float upper)
{
UInt16 uival = 0;
//m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue
//0-1
// float difference = upper - lower;
// we're trying to get a zero lower and modify all values equally so we get a percentage position
if (lower > 0)
{
upper -= lower;
val = val - lower;
// start with 500 upper and 200 lower.. subtract 200 from the upper and the value
}
else //if (lower < 0 && upper > 0)
{
// double negative, 0 minus negative 5 is 5.
upper += 0 - lower;
lower += 0 - lower;
val += 0 - lower;
}
if (upper == 0)
val = 0;
else
{
val /= upper;
}
uival = (UInt16)(val * UInt16.MaxValue);
return uival;
}
/// <summary>
/// Endian Swap
/// Swaps endianness if necessary
/// </summary>
/// <param name="arr">Input array</param>
/// <returns></returns>
public static byte[] ES(byte[] arr)
{
if (!BitConverter.IsLittleEndian)
Array.Reverse(arr);
return arr;
}
public static byte[] EndianSwap(byte[] arr, int offset, int len)
{
byte[] bendian = new byte[offset + len];
Buffer.BlockCopy(arr, offset, bendian, 0, len);
Array.Reverse(bendian);
return bendian;
}
public static byte[] WriteNullTerminatedString(string str)
{
byte[] output = new byte[str.Length + 1];
Char[] chr = str.ToCharArray();
int i = 0;
for (i = 0; i < chr.Length; i++)
{
output[i] = Convert.ToByte(chr[i]);
}
output[i] = Convert.ToByte('\0');
return output;
}
}
}
/*
switch (jointname)
{
case "mPelvis":
case "mTorso":
case "mNeck":
case "mHead":
case "mChest":
case "mHipLeft":
case "mHipRight":
case "mKneeLeft":
case "mKneeRight":
// XYZ->ZXY
t = x;
x = y;
y = t;
break;
case "mCollarLeft":
case "mCollarRight":
case "mElbowLeft":
case "mElbowRight":
// YZX ->ZXY
t = z;
z = x;
x = y;
y = t;
break;
case "mWristLeft":
case "mWristRight":
case "mShoulderLeft":
case "mShoulderRight":
// ZYX->ZXY
t = y;
y = z;
z = t;
break;
case "mAnkleLeft":
case "mAnkleRight":
// XYZ ->ZXY
t = x;
x = z;
z = y;
y = t;
break;
}
*/
Generated by GNU Enscript 1.6.5.90.