private void CheckRotateLimit(TransformElement element, float rotAngle)
{
var rotLimit = element.limit;
var offset = element.mode == TransformMode.XAxis ? 0.5f : -1f;
if ((rotAngle > rotLimit) || (rotAngle < rotLimit * offset))
{
if (!element.hasReachedLimit)
{
element.startTime = Time.timeSinceLevelLoad;
element.hasReachedLimit = true;
}
}
if (element.hasReachedLimit)
{
var diff = Time.timeSinceLevelLoad - element.startTime;
var rate = diff / element.changeDirSec;
element.velocity = Mathf.Lerp(element.maxVelocity, element.maxVelocity * -1f, rate);
}
var resetPos = element.mode == TransformMode.XAxis ? 0.28f : 0;
if ((rotAngle <= resetPos + 0.01f) && (rotAngle >= resetPos - 0.01f))
{
element.hasReachedLimit = false;
element.maxVelocity = element.velocity;
}
}
private DataList <FloatValue> mFloatList01; //version 3+
#endregion
#region Constructors
public Description(int apiVersion, EventHandler handler, ISection section)
: base(apiVersion, handler, section)
{
mLocalXForm = new TransformElement(apiVersion, handler);
mLODScales = new DataList <LODScale>(handler);
mFloatList01 = new DataList <FloatValue>(handler);
}
public static void Reset(this Transform t, TransformElement elements, Space space)
{
if ((elements & TransformElement.Position) != 0)
{
if (space == Space.World)
{
t.position = Vector3.zero;
}
else
{
t.localPosition = Vector3.zero;
}
}
if ((elements & TransformElement.Rotation) != 0)
{
if (space == Space.World)
{
t.rotation = Quaternion.identity;
}
else
{
t.localRotation = Quaternion.identity;
}
}
if ((elements & TransformElement.Scale) != 0)
{
t.localScale = Vector3.one;
}
}
private void AssignTransform(Transform transform, TransformElement element)
{
switch (element.name.ToLower())
{
case "position":
transform.position = MakeAssignedVector3(transform.position, element.coordinate, element.value);
break;
case "localposition":
transform.localPosition = MakeAssignedVector3(transform.localPosition, element.coordinate, element.value);
break;
case "rotaion":
transform.rotation = Quaternion.Euler(MakeAssignedVector3(transform.rotation.eulerAngles, element.coordinate, element.value));
break;
case "localrotation":
transform.localRotation = Quaternion.Euler(MakeAssignedVector3(transform.localRotation.eulerAngles, element.coordinate, element.value));
break;
case "localscale":
transform.localScale = MakeAssignedVector3(transform.localScale, element.coordinate, element.value);
break;
}
}
protected void Parse(Stream s, int count)
{
uint[] slotNames = new uint[count];
uint[] boneNames = new uint[count];
TransformElement[][] transformElements = new TransformElement[count][];
ConeElement[] coneElements = new ConeElement[count];
BinaryReader r = new BinaryReader(s);
for (int i = 0; i < slotNames.Length; i++)
{
slotNames[i] = r.ReadUInt32();
}
for (int i = 0; i < boneNames.Length; i++)
{
boneNames[i] = r.ReadUInt32();
}
for (int i = 0; i < transformElements.Length; i++)
{
transformElements[i] = new TransformElement[3];
transformElements[i][0] = new TransformElement(0, elementHandler, s); //X
transformElements[i][1] = new TransformElement(0, elementHandler, s); //Y
transformElements[i][2] = new TransformElement(0, elementHandler, s); //Z
}
for (int i = 0; i < coneElements.Length; i++)
{
coneElements[i] = new ConeElement(0, elementHandler, s);
}
for (int i = 0; i < count; i++)
{
this.Add(new ConePart(0, elementHandler, slotNames[i], boneNames[i],
transformElements[i][0], transformElements[i][1], transformElements[i][2], coneElements[i]));
}
}
public Part(int APIversion, EventHandler handler)
: base(APIversion, handler)
{
tX = new TransformElement(requestedApiVersion, handler);
tY = new TransformElement(requestedApiVersion, handler);
tZ = new TransformElement(requestedApiVersion, handler);
}
public ConePart(EventHandler handler)
: base(handler)
{
tX = new TransformElement(handler);
tY = new TransformElement(handler);
tZ = new TransformElement(handler);
}
public Part(int APIversion, EventHandler handler,
uint slotName, uint boneName, TransformElement tX, TransformElement tY, TransformElement tZ)
: base(APIversion, handler)
{
this.slotName = slotName;
this.boneName = boneName;
this.tX = new TransformElement(requestedApiVersion, handler, tX);
this.tY = new TransformElement(requestedApiVersion, handler, tY);
this.tZ = new TransformElement(requestedApiVersion, handler, tZ);
}
public Part(EventHandler handler,
uint slotName, uint boneName, TransformElement tX, TransformElement tY, TransformElement tZ)
: base(handler)
{
this.slotName = slotName;
this.boneName = boneName;
this.tX = new TransformElement(handler, tX);
this.tY = new TransformElement(handler, tY);
this.tZ = new TransformElement(handler, tZ);
}
public DistributeEffect(int apiVersion, EventHandler handler, ISection section)
: base(apiVersion, handler, section)
{
mPreTransform = new TransformElement(apiVersion, handler);
mSizeCurve = new DataList <FloatValue>(handler);
mPitchCurve = new DataList <FloatValue>(handler);
mRollCurve = new DataList <FloatValue>(handler);
mHeadingCurve = new DataList <FloatValue>(handler);
mColorCurve = new DataList <ColorValue>(handler);
mColorVary = new ColorValue(apiVersion, handler);
mAlphaCurve = new DataList <FloatValue>(handler);
mSurfaces = new DataList <Surface>(handler);
mAltitudeRange = new Vector2ValueLE(apiVersion, handler);
mDrawInfo = new ResourceReference(apiVersion, handler, section);
}
public static void Match(this Transform t, Transform other,
TransformElement elements)
{
if ((elements & TransformElement.Position) != 0)
{
t.position = other.position;
}
if ((elements & TransformElement.Rotation) != 0)
{
t.rotation = other.rotation;
}
if ((elements & TransformElement.Scale) != 0)
{
t.localScale = other.localScale;
}
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
savedIndentLevel = EditorGUI.indentLevel;
EditorGUI.indentLevel = 1;
// Get the actual instance of this FloatRange
TransformElement par = (TransformElement)Utilities.GUIUtilities.PropertyDrawerUtility.GetParent(property);
SerializedProperty axis = property.FindPropertyRelative("axis");
IPositionElement pe = par as IPositionElement;
IScaleElement se = par as IScaleElement;
FloatRange ar = (pe != null) ? pe.AxisRanges[axis.intValue] : se.AxisRanges[axis.intValue];
realwidth = r.width;
float padding = 4f;
float lablelWidth = 64f;
float fieldWidth = 56f;
float labeloffset = -82f;
float fieldOffset = -(fieldWidth * .5f) - padding;
float col2 = realwidth - r.width * .6666667f;
float col3 = realwidth - r.width * .3333333f;
float colend = realwidth;
float rowoffset = r.yMin;
ar.Min = EditorGUI.FloatField(new Rect(col2 + fieldOffset, rowoffset, fieldWidth, 16), GUIContent.none, ar.Min);
EditorGUI.LabelField(new Rect(col2 + labeloffset, rowoffset, lablelWidth, 16), new GUIContent("min"), "RightLabel");
ar.Max = EditorGUI.FloatField(new Rect(col3 + fieldOffset, rowoffset, fieldWidth, 16), GUIContent.none, ar.Max);
EditorGUI.LabelField(new Rect(col3 + labeloffset, rowoffset, lablelWidth, 16), new GUIContent("max"), "RightLabel");
ar.Resolution = EditorGUI.IntField(new Rect(colend + fieldOffset, rowoffset, fieldWidth, 16), GUIContent.none, ar.Resolution);
EditorGUI.LabelField(new Rect(colend + labeloffset, rowoffset, lablelWidth, 16), new GUIContent("res"), "RightLabel");
if (pe != null)
{
pe.AxisRanges[axis.intValue].ApplyValues();
}
else if (se != null)
{
se.AxisRanges[axis.intValue].ApplyValues();
}
EditorGUI.indentLevel = savedIndentLevel;
}
public static void ReadAllElements<T>(ref UdpKit.UdpBitStream bitstream, MsgType msgType, FrameBuffer buffer, int packetId, List<T> elements)
where T : TransformElement
{
Frame frame = buffer.frames[packetId];
bool isCurrentFrame = (packetId == buffer.CurrentIndex);
bool isPos = ((typeof(T) == typeof(PositionElement)));
for (int i = 0; i < elements.Count; i++)
{
TransformElement e = elements[i];
bool forcedUpdate = e.IsUpdateForced(msgType, packetId);
bool isKeyframe = e.IsKeyframe(packetId);
// Read element from the buffer if it is expected
if (forcedUpdate || e.sendCulling.ChangesType())
{
bool hasChanged = e.ReadFromBitstream(ref bitstream, msgType, frame, i, forcedUpdate, isKeyframe);
// reapply snapshot if this frame is mid lerping (current), this is more accurate than the reconstructed rot being used.
if (isCurrentFrame && hasChanged)
{
DebugX.Log("Mid lerp child update");
if (isPos)
e.Snapshot(frame.positions, i, true);
else
e.Snapshot(frame.rotations, i, true);
}
// Set the mask if this element sent an update
if (isPos)
i.SetBitInMask(ref frame.positionsMask, hasChanged);
else
i.SetBitInMask(ref frame.rotationsMask, hasChanged);
}
}
}
public static void WriteAllElements<T>(ref UdpKit.UdpBitStream bitstream, MsgType msgType, FrameBuffer buffer, int packetId, List<T> elements)
where T : TransformElement
{
Frame frame = buffer.frames[packetId];
for (int i = 0; i < elements.Count; i++)
{
TransformElement e = elements[i];
bool forcedUpdate = e.IsUpdateForced(msgType, packetId);
bool isKeyframe = e.IsKeyframe(packetId);
// Write this element to the stream if it is expected
if (forcedUpdate || e.sendCulling.ChangesType())
e.WriteToBitstream(ref bitstream, msgType, forcedUpdate, isKeyframe);
// Store the current transform in the frame buffer if this has local authority TODO: (may not actually be used anywhere)
if ((typeof(T) == typeof(PositionElement)))
frame.positions[i] = (e as PositionElement).Localized;
else
frame.rotations[i] = (e as RotationElement).Localized;
}
}
protected override void Parse(Stream stream)
{
var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);
s.Read(out mFlags);
//mFlags &= 0x3FFF;
s.Read(out mDensity);
s.Read(out mComponentName, StringType.ZeroDelimited);
s.Read(out mStart);
s.Read(out mSourceType);
s.Read(out mSourceSize);
mPreTransform = new TransformElement(0, handler, stream);
mSizeCurve = new DataList <FloatValue>(handler, stream);
s.Read(out mSizeVary);
mPitchCurve = new DataList <FloatValue>(handler, stream);
mRollCurve = new DataList <FloatValue>(handler, stream);
mHeadingCurve = new DataList <FloatValue>(handler, stream);
s.Read(out mPitchVary);
s.Read(out mRollVary);
s.Read(out mHeadingVary);
s.Read(out mPitchOffset);
s.Read(out mRollOffset);
s.Read(out mHeadingOffset);
mColorCurve = new DataList <ColorValue>(handler, stream);
mColorVary = new ColorValue(requestedApiVersion, handler, stream);
mAlphaCurve = new DataList <FloatValue>(handler, stream);
s.Read(out mAlphaVary);
mSurfaces = new DataList <Surface>(handler, stream);
s.Read(out mEmitMapId);
s.Read(out mColorMapId);
s.Read(out mPinMapId);
mAltitudeRange = new Vector2ValueLE(requestedApiVersion, handler, stream);
mDrawInfo = new ResourceReference(requestedApiVersion, handler, mSection, stream);
s.Read(out mOverrideSet);
s.Read(out mMessageId);
}
protected override void Parse(Stream stream)
{
var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);
s.Read(out mComponentType);
s.Read(out mFlags);
mLocalXForm = new TransformElement(requestedApiVersion, handler, stream);
s.Read(out mLODBegin);
s.Read(out mLODEnd);
mLODScales = new DataList <LODScale>(handler, stream);
s.Read(out mEmitScaleBegin); //1.0
s.Read(out mEmitScaleEnd); //1.0
s.Read(out mSizeScaleBegin); //1.0
s.Read(out mSizeScaleEnd); //1.0
s.Read(out mAlphaScaleBegin); //1.0
s.Read(out mAlphaScaleEnd); //1.0
s.Read(out mAppFlags);
s.Read(out mAppFlagsMask);
s.Read(out mSelectionGroup);
s.Read(out mSelectionChance);
s.Read(out mTimeScale);
s.Read(out mComponentIndex);
if (mSection.Version >= 2 && stream.Position < stream.Length)
{
s.Read(out mByte03); //version 2+
s.Read(out mByte04); //version 2+
}
if (mSection.Version >= 3 && stream.Position < stream.Length)
{
mFloatList01 = new DataList <FloatValue>(handler, stream);//version 3+
}
else
{
mFloatList01 = new DataList <FloatValue>(handler);
}
}
public SlottedPart(int APIversion, EventHandler handler, uint slotName, uint boneName, SlotPlacement slotPlacementFlags,
TransformElement tX, TransformElement tY, TransformElement tZ)
: base(APIversion, handler, slotName, boneName, tX, tY, tZ)
{
this.slotPlacementFlags = slotPlacementFlags;
}
public static void Match(this Transform t, Transform other, TransformElement elements)
{
if ((elements & TransformElement.Position) != 0)
{
t.position = other.position;
}
if ((elements & TransformElement.Rotation) != 0)
{
t.rotation = other.rotation;
}
if ((elements & TransformElement.Scale) != 0)
{
t.localScale = other.localScale;
}
}
public static void Reset(this Transform t, TransformElement elements)
{
Reset(t, elements, Space.World);
}
public static void Reset(this Transform t, TransformElement elements, Space space)
{
if ((elements & TransformElement.Position) != 0)
{
if (space == Space.World)
{
t.position = Vector3.zero;
}
else
{
t.localPosition = Vector3.zero;
}
}
if ((elements & TransformElement.Rotation) != 0)
{
if (space == Space.World)
{
t.rotation = Quaternion.identity;
}
else
{
t.localRotation = Quaternion.identity;
}
}
if ((elements & TransformElement.Scale) != 0)
{
t.localScale = Vector3.one;
}
}
public static void Reset(this Transform t, TransformElement elements)
{
Reset(t, elements, Space.World);
}
