public static TransformData Interpolate(TransformData current, TransformData target, float fac)
{
return new TransformData(
Vector3.Lerp(current.position, target.position, fac),
Quaternion.Slerp(current.rotation, target.rotation, fac),
Vector3.Lerp(current.scale, target.scale, fac)
);
}
public Quaternion localRotation; //magic
public static TransformData Lerp(TransformData from, TransformData to, long time) {
if (from.leapTime == to.leapTime) {
return from;
}
float fraction = (float)(time - from.leapTime) / (float)(to.leapTime - from.leapTime);
return new TransformData() {
leapTime = time,
localPosition = Vector3.Lerp(from.localPosition, to.localPosition, fraction),
localRotation = Quaternion.Slerp(from.localRotation, to.localRotation, fraction)
};
}
protected override void InverseTransform(ref TransformData transData)
{
double x = transData.X;
double y = transData.Y;
// NOTE: when x and y are zero, this will divide by zero and return NaN
double invertDistance = Utility.Lerp (1.0, DefaultRadius2 / ((x * x) + (y * y)), Data.Amount);
transData.X = x * invertDistance;
transData.Y = y * invertDistance;
}
public void AnimateZoom(Rect rectToZoom)
{
double scaleW = RenderSize.Width / rectToZoom.Width;
double scaleH = RenderSize.Height / rectToZoom.Height;
double scale = Math.Min(scaleW, scaleH);
double rectCenterX = rectToZoom.X + rectToZoom.Width / 2;
double rectCenterY = rectToZoom.Y + rectToZoom.Height / 2;
double centerX = RenderSize.Width / 2;
double centerY = RenderSize.Height / 2;
mySavedTransformData = AnimateTo(centerX, rectCenterX, centerY, rectCenterY, scale);
}
private void SavePlayerPosition ()
{
GameObject tempObject;
tempObject = GameObject.Find ("Player");
if (tempObject != null) {
playerTransformData = tempObject.transform.Clone ();
tempObject = null;
Debug.Log ("SetPlayerPosition x:" + playerTransformData.position.x + " y:" + playerTransformData.position.y);
} else {
Debug.LogWarning ("NOT HERE!");
}
}
public static void Apply(TransformData source, Transform target, Space space = Space.Self)
{
if (space == Space.Self)
{
target.localPosition = source.position;
target.localRotation = source.rotation;
target.localScale = source.scale;
}
else
{
target.position = source.position;
target.rotation = source.rotation;
target.localScale = source.scale;
}
}
public static TransformData Clone( this Transform transform )
{
TransformData td = new TransformData();
td.position = transform.position;
td.localPosition = transform.localPosition;
td.rotation = transform.rotation;
td.localRotation = transform.localRotation;
td.localScale = transform.localScale;
td.parent = transform.parent;
return td;
}
public GameTablePanel()
{
InitializeComponent();
Application.Current.RootVisual.KeyDown += delegate(object sender, KeyEventArgs e)
{
if (e.Key == Key.Escape && mySavedTransformData != null)
{
Animate(mySavedTransformData.TranslateTransform, mySavedTransformData.ScaleTransform, mySavedTransformData.PlaneProjection);
mySavedTransformData = null;
e.Handled = true;
}
};
AddEventHandlers(TopPlayerPanel);
AddEventHandlers(BottomPlayerPanel);
AddEventHandlers(LeftPlayerPanel);
AddEventHandlers(RightPlayerPanel);
}
void CopyTransforms()
{
backedTransforms.Clear ();
for ( int i = 0 ; i < Selection.gameObjects.Length; i++ )
{
GameObject go = Selection.gameObjects[i];
Transform t = go.transform;
int id = go.GetInstanceID();
TransformData data = new TransformData ()
{
localPosition = t.localPosition,
localScale = t.localScale,
localRotation = t.localRotation
};
backedTransforms.Add ( id, data );
}
Debug.Log ( "Copied " + backedTransforms.Count + " transforms." );
}
public static Vector2 TranslateUV(Vector2 source, TransformData transformData)
{
return source + transformData.Vector;
}
private void Animate(TranslateTransform newTranslateTransform, ScaleTransform newScaleTransform, PlaneProjection newPlaneProjection, PowerEase ease = null)
{
myCurrentTransformData = new TransformData(newPlaneProjection, newTranslateTransform, newScaleTransform);
UIUtil.StartAnimation(0.5,
new AnimationInfo(myTranslateTransform, new PropertyPath(TranslateTransform.XProperty), myTranslateTransform.X, newTranslateTransform.X, ease),
new AnimationInfo(myTranslateTransform, new PropertyPath(TranslateTransform.YProperty), myTranslateTransform.Y, newTranslateTransform.Y, ease),
new AnimationInfo(myScaleTransform, new PropertyPath(ScaleTransform.ScaleXProperty), myScaleTransform.ScaleX, newScaleTransform.ScaleX, ease),
new AnimationInfo(myScaleTransform, new PropertyPath(ScaleTransform.ScaleYProperty), myScaleTransform.ScaleY, newScaleTransform.ScaleY, ease),
new AnimationInfo(myScaleTransform, new PropertyPath(ScaleTransform.CenterXProperty), myScaleTransform.CenterX, newScaleTransform.CenterX, ease),
new AnimationInfo(myScaleTransform, new PropertyPath(ScaleTransform.CenterYProperty), myScaleTransform.CenterY, newScaleTransform.CenterY, ease),
new AnimationInfo(myPlaneProjection, new PropertyPath(PlaneProjection.RotationXProperty), myPlaneProjection.RotationX, newPlaneProjection.RotationX, ease),
new AnimationInfo(myPlaneProjection, new PropertyPath(PlaneProjection.LocalOffsetZProperty), myPlaneProjection.LocalOffsetZ, newPlaneProjection.LocalOffsetZ, ease),
new AnimationInfo(myPlaneProjection, new PropertyPath(PlaneProjection.LocalOffsetYProperty), myPlaneProjection.LocalOffsetY, newPlaneProjection.LocalOffsetY, ease));
}
void Awake()
{
this.rigidBody = this.GetComponent<Rigidbody>();
this.rigidBody.isKinematic = true;
this.OriginalTranform = new TransformData(this.transform);
}
private void ScreenStartMove(Vector2 mouseDelta)
{
StartData = CameraHolder.Reference.transform;
}
public PlayerData(SlotPanelData inventoryPanel, SlotPanelData equipmentPanel, PlayerStatData playerStats, TransformData transformData)
{
this.inventoryPanel = inventoryPanel;
this.equipmentPanel = equipmentPanel;
this.playerStats = playerStats;
this.transformData = transformData;
}
private List <FuseResult <T> > Format(List <AnalyzeResult> results)
{
var finalOutput = new List <FuseResult <T> >();
var transformers = new List <TransformResult>();
if (_options.includeMatches)
{
transformers.Add((AnalyzeResult result, ref TransformData data) => {
var output = result.output;
data.matches = new List <FuseMatch>();
for (var i = 0; i < output.Count; i++)
{
var item = output[i];
if (item.matchedIndices.Count == 0)
{
continue;
}
var entry = new FuseMatch
{
indicies = item.matchedIndices,
value = item.value
};
if (!string.IsNullOrEmpty(item.key))
{
entry.key = item.key;
}
if (item.arrayIndex > -1)
{
entry.arrayIndex = item.arrayIndex;
}
data.matches.Add(entry);
}
});
}
if (_options.includeScore)
{
transformers.Add((AnalyzeResult result, ref TransformData data) =>
{
data.score = result.score;
});
}
for (var i = 0; i < results.Count; i++)
{
var result = results[i];
if (!string.IsNullOrEmpty(_options.id))
{
var value = _options.getFn(result.item, _options.id);
if (value is List <string> )
{
result.item = ((List <string>)value)[0];
}
else if (value is string)
{
result.item = value;
}
}
if (transformers.Count == 0)
{
finalOutput.Add(new FuseResult <T>
{
item = (T)result.item
});
continue;
}
var data = new TransformData {
item = result.item
};
for (var j = 0; j < transformers.Count; j++)
{
transformers[j](result, ref data);
}
finalOutput.Add(new FuseResult <T>
{
item = (T)data.item,
score = data.score,
matches = data.matches
});
}
return(finalOutput);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
// Using BeginProperty / EndProperty on the parent property means that
// prefab override logic works on the entire property.
EditorGUI.BeginProperty(position, label, property);
property.isExpanded = EditorGUI.Foldout(new Rect(position.x, position.y, position.width, 20f), property.isExpanded, label.text);
if (property.isExpanded)
{
// Calculate rects
var posRect = new Rect(position.x, position.y + 20f, position.width, position.height);
var rotRect = new Rect(position.x, position.y + 40f, position.width, position.height);
var scaleRect = new Rect(position.x, position.y + 60f, position.width, position.height);
bool largeEnough = (EditorGUIUtility.currentViewWidth > 345);
if (largeEnough)
{
EditorGUI.PropertyField(posRect, property.FindPropertyRelative("position"));
EditorGUI.PropertyField(rotRect, property.FindPropertyRelative("eulerAngles"));
EditorGUI.PropertyField(scaleRect, property.FindPropertyRelative("scale"));
}
else
{
EditorGUI.PropertyField(posRect, property.FindPropertyRelative("position"), new GUIContent(""));
EditorGUI.PropertyField(rotRect, property.FindPropertyRelative("eulerAngles"), new GUIContent(""));
EditorGUI.PropertyField(scaleRect, property.FindPropertyRelative("scale"), new GUIContent(""));
}
float barWidth = position.width * 0.91f;
if (largeEnough)
{
barWidth = (position.width * 0.56f);
}
float xPosition = position.x + (position.width - barWidth);
TransformData availableData = TransformDataHolder.data;
if (availableData != null)
{
barWidth = (barWidth / 2f) - 15f;
}
var buttonOneRect = new Rect(xPosition, position.y + 80f, barWidth, 20f);
if (GUI.Button(buttonOneRect, "Reset Data"))
{
property.FindPropertyRelative("position").vector3Value = Vector3.zero;
property.FindPropertyRelative("eulerAngles").vector3Value = Vector3.zero;
property.FindPropertyRelative("scale").vector3Value = Vector3.one;
}
if (availableData != null)
{
var buttonTwoRect = new Rect(xPosition + barWidth + 5f, position.y + 80f, barWidth, 20f);
if (GUI.Button(buttonTwoRect, "Paste Data"))
{
availableData = TransformDataHolder.PasteData();
property.FindPropertyRelative("position").vector3Value = availableData.position;
property.FindPropertyRelative("eulerAngles").vector3Value = availableData.eulerAngles;
property.FindPropertyRelative("scale").vector3Value = availableData.scale;
}
var oldColor = GUI.backgroundColor;
GUI.backgroundColor = new Color(1f, 0.25f, 0.25f);
var buttonThreeRect = new Rect(position.width, position.y + 80f, 20f, 20f);
if (GUI.Button(buttonThreeRect, "X"))
{
availableData = TransformDataHolder.PasteData();
}
GUI.backgroundColor = oldColor;
}
}
EditorGUI.EndProperty();
}
public void TryGetGameObjectNull()
{
TransformData invalid = null;
Assert.IsNull(invalid.TryGetGameObject());
}
public static void SetLocalTransformData(Transform t, TransformData data)
{
t.localPosition = data.position;
t.localRotation = Quaternion.Euler(data.eulerAngles);
t.localScale = data.scale;
}
public void ScalePlayerByTransform(TransformData target)
{
ScalePlayer(target.Transform.localScale.y);
}
public static void AssignTransform(Transform UnityTranform, TransformData OriginalTranform)
{
UnityTranform.position = OriginalTranform.Position;
UnityTranform.rotation = OriginalTranform.Rotation;
UnityTranform.localScale = OriginalTranform.Scale;
}
public EventData Set(TransformData source, TransformData target)
{
EventSource = source;
EventTarget = target;
return(this);
}
/// <summary> /// Deform the vertex data in this method by modifying the vertexData argument and returning it. /// This method is might be running on another thread (if Update Mode is set to UpdateAsync) so you can't access /// things like transforms or anything else Unity manages. /// If you need access to something and Unity won't let you get it, override and cache it in the PreModify method. /// </summary> /// <param name="transformData">The current transform data of the mesh.</param> /// <param name="vertexDataBounds">The bounds of the current vertex data.</param> /// <returns>The vertexData you return will be sent to the next deformer component or applied to the mesh if this /// is the last deformer component.</returns> public abstract MeshData Modify(MeshData meshData, TransformData transformData, Bounds vertexDataBounds);
public void OnSceneGUI()
{
if (UseGizmo && !debugTransform)
{
var data = Target.Lerp(DebugTime);
var matrix = Handles.matrix;
var rotationMatrix = Matrix4x4.TRS(data.Position, data.Rotation, data.Scale);
Handles.matrix = rotationMatrix;
Handles.DrawWireCube(Vector3.zero, Vector3.one);
Handles.matrix = matrix;
}
using (var cc = Disposables.ChangeCheck()) {
if ((Curve == null) || Curve.CurvePositions.IsNullOrEmpty())
{
return;
}
var pos = Curve.CurvePositions;
for (var i = 0; i < pos.Count; i++)
{
using (var undoCheck = Disposables.ChangeCheck()) {
var tdPos = Curve.CurvePositions[i].Position;
if (!Target.UseGlobalSpace)
{
tdPos = Target.transform.TransformPoint(tdPos);
}
var tdScl = Curve.CurvePositions[i].Scale;
var tdRot = Curve.CurvePositions[i].Rotation;
switch (MyMode)
{
case Mode.Move:
tdPos = Handles.DoPositionHandle(tdPos, tdRot);
break;
case Mode.Rotate:
tdRot = Handles.DoRotationHandle(tdRot, tdPos);
break;
case Mode.Scale:
tdScl = Handles.ScaleHandle(tdScl, tdPos, tdRot, HandleUtility.GetHandleSize(tdPos));
break;
case Mode.MoveRotate:
tdPos = Handles.DoPositionHandle(tdPos, tdRot);
tdRot = Handles.DoRotationHandle(tdRot, tdPos);
break;
case Mode.RotateShowMoveArrows:
Handles.DoPositionHandle(tdPos, tdRot);
tdRot = Handles.DoRotationHandle(tdRot, tdPos);
break;
}
Handles.Label(tdPos, new GUIContent($"Index: {i}"));
if (!Target.UseGlobalSpace)
{
tdPos = Target.transform.InverseTransformPoint(tdPos);
}
//pos[i].UpdateData(tdPos, tdRot, tdScl);
pos[i] = new TransformData(tdPos, tdRot, tdScl);
if (undoCheck.changed)
{
Undo.RecordObject(Curve, "Changed Curve Position");
}
}
}
Curve.CurvePositions = pos;
for (float i = 0; i < 1f; i += resolution)
{
Handles.DrawLine(Target.Lerp(i).Position, Target.Lerp((i + resolution).Clamp()).Position);
}
if (cc.changed)
{
serializedObject.ApplyModifiedProperties();
EditorUtility.SetDirty(target);
}
}
}
public static Vector2 FlipUVY(Vector2 source, TransformData transformData)
{
source.y = 1-source.y;
return source;
}
public static void CopyData(TransformData copy)
{
data = copy;
}
private void OnRailState()
{
DebugExecute("OnRail");
// Translate snake
// Slow down boot towards the end of rail
float boost = 0.3f;
float slowDownStart = 5;
float slowDownEnd = 2;
float distanceToEnd = Mathf.Round(spline.length - traversed);
if (distanceToEnd < slowDownStart - slowDownEnd && spline.outgoingSpline == null)
{
float zeroToOne = 1 - (distanceToEnd - slowDownEnd) / slowDownStart;
boost = Mathf.Lerp(boost, 0, zeroToOne);
}
// Calculate speed
speed += handling.acceleration;
speed = Mathf.Min(speed, handling.maxSpeed + boost);
speed = Mathf.Max(speed, 0);
traversed += speed;
// Transition to the next, outgoing spline, if any
if (traversed > spline.length && spline.outgoingSpline != null)
{
traversed = traversed - spline.length;
spline = spline.outgoingSpline;
// traversed = spline.length;
// currentState = SnakeState.Move;
}
TransformData data = spline.GetPointBaked(traversed);
transform.position = data.position;
transform.rotation = data.rotation;
// Store current positon point
body.skeleton.PrependJoint(transform.position);
//
body.UpdateBody(speed);
// When snake comes to an end of the rail
if (traversed >= spline.length)
{
if (hole == null || hole.type == HoleType.Hole)
{
currentState = SnakeState.Move;
}
else if (hole.type == HoleType.Exit)
{
currentState = SnakeState.Idle;
GameManager.INSTANCE.currentState = GameManager.GameState.LevelFinished;
}
}
}
protected void PlayActionSequence ( ArrayList p_actionSequence )
{
// check here if cueueble or action is uninteractibe.
if( !this.IsInteractible() )
{
if( m_bEventIsCueable )
{
// Sanity check..
// 1. Should not Add ActionSequence that is currently playing
// 2. Should not Add ActionSequence that is already in cue
foreach( string action in p_actionSequence )
{
bool containsAction = false;
foreach( string cuedAction in m_cuedActions )
{
if( action.Equals(cuedAction) )
containsAction = true;
}
if( !containsAction ) { m_cuedActions.Add(action); }
#if DEBUG_CUEABLES
if( containsAction ) Debug.LogError("Dragon::PlayActionSequence Dragon is not Interactible. adding "+action+" to cue.");
else Debug.LogError("Dragon::PlayActionSequence Dragon is not Interactible and already contains cueable "+action+" action.");
#else
if( containsAction ) Log("Dragon::PlayActionSequence Dragon is not Interactible. adding "+action+" to cue.");
else Log("Dragon::PlayActionSequence Dragon is not Interactible and already contains cueable "+action+" action.");
#endif
}
return;
}
#if DEBUG_CUEABLES
Debug.LogError("Dragon::PlayActionSequence Cannot Play this Action because Action is not Interactibe.");
//Debug.Break();
#else
//Log("Dragon::PlayActionSequence Cannot Play this Action:"+MiniJSON.jsonEncode(p_actionSequence)+" because Action is not Interactibe.");
Debug.LogWarning("Dragon::PlayActionSequence Cannot Play this Action:"+MiniJSON.jsonEncode(p_actionSequence)+" because Action is not Interactibe. \n");
#endif
return;
}
// clear actions
DragonAnimationQueue.getInstance().ClearAll();
SoundManager.Instance.StopAnimationSound( PettingMain.Instance.HeadSoundContainer );
SoundManager.Instance.StopAnimationSound( PettingMain.Instance.BodySoundContainer );
SoundManager.Instance.StopAnimationSound( PettingMain.Instance.HeadAndBodySoundContainer );
foreach( string action in p_actionSequence )
{
// Body Animations
ArrayList bodyActionSequence = SequenceReader.GetInstance().ReadBodySequence(action);
Log("----------- Playing Reaction:"+action+" -----------");
//LogWarning(">>>>>>> Checking action: \""+action+"\"\n");
if( bodyActionSequence != null )
{
// +KJ:06132013 Shared Parameter. this supports the same random value that a cue is sharing
foreach( object actionData in bodyActionSequence )
{
ArrayList actionDataList = actionData as ArrayList;
BodyData bodyData = new BodyData();
bodyData.Action = action;
bodyData.Start = Utility.ParseToInt(actionDataList[0]);
bodyData.ActionKey = actionDataList[1].ToString();
bodyData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
bodyData.Param = actionDataList[3] as Hashtable;
}
bodyData.ExtractHashtableValues( bodyData.Param );
bodyData.EventTrigger = this.FormulateEventTriggers( bodyData.Param );
DragonAnimationQueue.getInstance().AddBodyCue( bodyData.GenerateHashtable() );
}
}
// Head Animations
ArrayList headActionSequence = SequenceReader.GetInstance().ReadHeadSequence(action);
if( headActionSequence != null )
{
foreach( object actionData in headActionSequence )
{
ArrayList actionDataList = actionData as ArrayList;
HeadData headData = new HeadData();
headData.Action = action;
headData.Start = Utility.ParseToInt(actionDataList[0]);
headData.ActionKey = actionDataList[1].ToString();
headData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
headData.Param = actionDataList[3] as Hashtable;
}
headData.ExtractHashtableValues( headData.Param );
headData.EventTrigger = this.FormulateEventTriggers( headData.Param );
DragonAnimationQueue.getInstance().AddHeadCue( headData.GenerateHashtable() ) ;
}
}
// Update Queue
ArrayList updateActionQueue = SequenceReader.GetInstance().ReadUpdate(action);
if( updateActionQueue != null )
{
foreach( object actionData in updateActionQueue )
{
ArrayList actionDataList = actionData as ArrayList;
UpdateData updateData = new UpdateData();
updateData.Action = action;
updateData.Start = Utility.ParseToInt(actionDataList[0]);
updateData.ActionKey = actionDataList[1].ToString();
updateData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
updateData.Param = actionDataList[3] as Hashtable;
}
updateData.EventTrigger = this.FormulateEventTriggers( updateData.Param );
DragonAnimationQueue.getInstance().AddUpdateCue( updateData.GenerateHashtable() );
}
}
// Transition Queue
ArrayList transitionQueue = SequenceReader.GetInstance().ReadTransform(action);
if( transitionQueue != null )
{
foreach( object actionData in transitionQueue )
{
ArrayList actionDataList = actionData as ArrayList;
TransformData transformData = new TransformData();
transformData.Action = action;
transformData.Start = Utility.ParseToInt(actionDataList[0]);
transformData.ActionKey = actionDataList[1].ToString();
transformData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
transformData.Param = actionDataList[3] as Hashtable;
}
transformData.EventTrigger = this.FormulateEventTriggers( transformData.Param );
DragonAnimationQueue.getInstance().AddTransformCue( transformData.GenerateHashtable() );
}
}
ArrayList cameraQueue = SequenceReader.GetInstance().ReadCamera(action);
if( cameraQueue != null )
{
foreach( object actionData in cameraQueue )
{
ArrayList actionDataList = actionData as ArrayList;
CameraData cameraData = new CameraData();
cameraData.Action = action;
cameraData.Start = Utility.ParseToInt(actionDataList[0]);
cameraData.ActionKey = actionDataList[1].ToString();
cameraData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
cameraData.Param = actionDataList[3] as Hashtable;
}
cameraData.EventTrigger = this.FormulateEventTriggers( cameraData.Param );
DragonAnimationQueue.getInstance().AddCameraCue( cameraData.GenerateHashtable() );
}
}
ArrayList eventQueue = SequenceReader.GetInstance().ReadEventTriggers(action);
if( eventQueue != null )
{
foreach( object actionData in eventQueue )
{
ArrayList actionDataList = actionData as ArrayList;
EventData eventData = new EventData();
eventData.Action = action;
eventData.Start = Utility.ParseToInt(actionDataList[0]);
eventData.ActionKey = actionDataList[1].ToString();
eventData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
eventData.Param = actionDataList[3] as Hashtable;
}
eventData.EventTrigger = this.FormulateEventTriggers( eventData.Param );
DragonAnimationQueue.getInstance().AddEventCue( eventData.GenerateHashtable() );
}
}
// + LA 072613
ArrayList soundQueue = SequenceReader.GetInstance().ReadSounds(action);
if( soundQueue != null )
{
foreach( object actionData in soundQueue )
{
ArrayList actionDataList = actionData as ArrayList;
SoundData soundData = new SoundData();
soundData.Action = action;
soundData.Start = Utility.ParseToInt(actionDataList[0]);
soundData.ActionKey = actionDataList[1].ToString();
soundData.Duration = float.Parse(actionDataList[2].ToString());
if( actionDataList.Count > 3 )
{
soundData.Param = actionDataList[3] as Hashtable;
}
soundData.EventTrigger = this.FormulateEventTriggers( soundData.Param );
DragonAnimationQueue.getInstance().AddSoundCue( soundData.GenerateHashtable() );
}
}
// - LA
}
DragonAnimationQueue.getInstance().PlayQueuedAnimations();
}
public static Vector2 FlipUVXY(Vector2 source, TransformData transformData)
{
return new Vector2(source.y,source.x);
}
protected void finishRecording(ProgressBar progress)
{
progress.Begin(5, "Saving Recording", "", () => {
if (!_isRecording)
{
return;
}
_isRecording = false;
//Turn on auto-pushing for all auto-proxy components
foreach (var autoProxy in GetComponentsInChildren <AutoValueProxy>())
{
autoProxy.autoPushingEnabled = true;
}
progress.Begin(1, "", "Reverting Scene State", () => {
foreach (var pair in _initialTransformData)
{
pair.Key.localPosition = pair.Value.localPosition;
pair.Key.localRotation = pair.Value.localRotation;
pair.Key.localScale = pair.Value.localScale;
pair.Key.gameObject.SetActive(pair.Value.enabled);
}
foreach (var pair in _initialActivityData)
{
EditorUtility.SetObjectEnabled(pair.Key, pair.Value);
}
});
progress.Begin(1, "", "Patching Materials: ", () => {
GetComponentsInChildren(true, _recorders);
foreach (var recorder in _recorders)
{
DestroyImmediate(recorder);
}
//Patch up renderer references to materials
var allMaterials = Resources.FindObjectsOfTypeAll <Material>().
Query().
Where(AssetDatabase.IsMainAsset).
ToList();
var renderers = GetComponentsInChildren <Renderer>(includeInactive: true);
progress.Begin(renderers.Length, "", "", () => {
foreach (var renderer in renderers)
{
progress.Step(renderer.name);
var materials = renderer.sharedMaterials;
for (int i = 0; i < materials.Length; i++)
{
var material = materials[i];
if (!AssetDatabase.IsMainAsset(material))
{
var matchingMaterial = allMaterials.Query().FirstOrDefault(m => material.name.Contains(m.name) &&
material.shader == m.shader);
if (matchingMaterial != null)
{
materials[i] = matchingMaterial;
}
}
}
renderer.sharedMaterials = materials;
}
});
});
progress.Begin(_behaviourActivity.Count, "", "Converting Activity Data: ", () => {
foreach (var pair in _behaviourActivity)
{
var targetBehaviour = pair.Key;
var activityData = pair.Value;
progress.Step(targetBehaviour.name);
string path = AnimationUtility.CalculateTransformPath(targetBehaviour.transform, transform);
Type type = targetBehaviour.GetType();
string propertyName = "m_Enabled";
AnimationCurve curve = new AnimationCurve();
foreach (var dataPoint in activityData)
{
int index = curve.AddKey(dataPoint.time, dataPoint.enabled ? 1 : 0);
AnimationUtility.SetKeyLeftTangentMode(curve, index, AnimationUtility.TangentMode.Constant);
AnimationUtility.SetKeyRightTangentMode(curve, index, AnimationUtility.TangentMode.Constant);
}
if (curve.IsConstant())
{
continue;
}
var binding = EditorCurveBinding.FloatCurve(path, type, propertyName);
if (_curves.ContainsKey(binding))
{
Debug.LogError("Binding already existed?");
Debug.LogError(binding.path + " : " + binding.propertyName);
continue;
}
_curves.Add(binding, curve);
}
});
progress.Begin(_transformData.Count, "", "Converting Transform Data: ", () => {
foreach (var pair in _transformData)
{
var targetTransform = pair.Key;
var targetData = pair.Value;
progress.Step(targetTransform.name);
string path = AnimationUtility.CalculateTransformPath(targetTransform, transform);
bool isActivityConstant = true;
bool isPositionConstant = true;
bool isRotationConstant = true;
bool isScaleConstant = true;
{
bool startEnabled = targetData[0].enabled;
Vector3 startPosition = targetData[0].localPosition;
Quaternion startRotation = targetData[0].localRotation;
Vector3 startScale = targetData[0].localScale;
for (int i = 1; i < targetData.Count; i++)
{
isActivityConstant &= targetData[i].enabled == startEnabled;
isPositionConstant &= targetData[i].localPosition == startPosition;
isRotationConstant &= targetData[i].localRotation == startRotation;
isScaleConstant &= targetData[i].localScale == startScale;
}
}
for (int i = 0; i < TransformData.CURVE_COUNT; i++)
{
string propertyName = TransformData.GetName(i);
Type type = typeof(Transform);
AnimationCurve curve = new AnimationCurve();
var dataType = TransformData.GetDataType(i);
switch (dataType)
{
case TransformDataType.Position:
if (isPositionConstant)
{
continue;
}
break;
case TransformDataType.Rotation:
if (isRotationConstant)
{
continue;
}
break;
case TransformDataType.Scale:
if (isScaleConstant)
{
continue;
}
break;
case TransformDataType.Activity:
if (isActivityConstant)
{
continue;
}
type = typeof(GameObject);
break;
}
for (int j = 0; j < targetData.Count; j++)
{
int index = curve.AddKey(targetData[j].time, targetData[j].GetFloat(i));
if (dataType == TransformDataType.Activity)
{
AnimationUtility.SetKeyLeftTangentMode(curve, index, AnimationUtility.TangentMode.Constant);
AnimationUtility.SetKeyRightTangentMode(curve, index, AnimationUtility.TangentMode.Constant);
}
}
var binding = EditorCurveBinding.FloatCurve(path, type, propertyName);
if (_curves.ContainsKey(binding))
{
Debug.LogError("Duplicate object was created??");
Debug.LogError("Named " + targetTransform.name + " : " + binding.path + " : " + binding.propertyName);
}
else
{
_curves.Add(binding, curve);
}
}
}
});
progress.Begin(_curves.Count, "", "Compressing Data: ", () => {
foreach (var pair in _curves)
{
EditorCurveBinding binding = pair.Key;
AnimationCurve curve = pair.Value;
progress.Step(binding.propertyName);
GameObject animationGameObject;
{
var animatedObj = AnimationUtility.GetAnimatedObject(gameObject, binding);
if (animatedObj is GameObject)
{
animationGameObject = animatedObj as GameObject;
}
else
{
animationGameObject = (animatedObj as Component).gameObject;
}
}
//But if the curve is constant, just get rid of it!
if (curve.IsConstant())
{
//Check to make sure there are no other matching curves that are
//non constant. If X and Y are constant but Z is not, we need to
//keep them all :(
if (_curves.Query().Where(p => p.Key.path == binding.path &&
p.Key.type == binding.type &&
p.Key.propertyName.TrimEnd(2) == binding.propertyName.TrimEnd(2)).
All(k => k.Value.IsConstant()))
{
continue;
}
}
//First do a lossless compression
curve = AnimationCurveUtil.Compress(curve, Mathf.Epsilon);
Transform targetTransform = null;
var targetObj = AnimationUtility.GetAnimatedObject(gameObject, binding);
if (targetObj is GameObject)
{
targetTransform = (targetObj as GameObject).transform;
}
else if (targetObj is Component)
{
targetTransform = (targetObj as Component).transform;
}
else
{
Debug.LogError("Target obj was of type " + targetObj.GetType().Name);
}
var dataRecorder = targetTransform.GetComponent <RecordedData>();
if (dataRecorder == null)
{
dataRecorder = targetTransform.gameObject.AddComponent <RecordedData>();
}
dataRecorder.data.Add(new RecordedData.EditorCurveBindingData()
{
path = binding.path,
propertyName = binding.propertyName,
typeName = binding.type.Name,
curve = curve
});
}
});
progress.Step("Finalizing Prefab...");
var postProcessComponent = gameObject.AddComponent <HierarchyPostProcess>();
GameObject myGameObject = gameObject;
DestroyImmediate(this);
string targetFolderPath = targetFolder.Path;
if (targetFolderPath == null)
{
if (myGameObject.scene.IsValid() && !string.IsNullOrEmpty(myGameObject.scene.path))
{
string sceneFolder = Path.GetDirectoryName(myGameObject.scene.path);
targetFolderPath = Path.Combine(sceneFolder, "Recordings");
}
else
{
targetFolderPath = Path.Combine("Assets", "Recordings");
}
}
int folderSuffix = 1;
string finalSubFolder;
do
{
finalSubFolder = Path.Combine(targetFolderPath, recordingName + " " + folderSuffix.ToString().PadLeft(2, '0'));
folderSuffix++;
} while (Directory.Exists(finalSubFolder));
Directory.CreateDirectory(finalSubFolder);
AssetDatabase.Refresh();
postProcessComponent.recordingName = recordingName;
postProcessComponent.assetFolder.Path = finalSubFolder;
postProcessComponent.leapData = _leapData;
string prefabPath = Path.Combine(finalSubFolder, recordingName + " Raw.prefab");
PrefabUtility.CreatePrefab(prefabPath.Replace('\\', '/'), myGameObject);
AssetDatabase.Refresh();
EditorApplication.isPlaying = false;
});
}
protected abstract void InverseTransform(ref TransformData data);
protected void recordData()
{
using (new ProfilerSample("Dispatch PreRecord Event")) {
if (OnPreRecordFrame != null)
{
OnPreRecordFrame();
}
}
using (new ProfilerSample("Get Components In Hierarchy")) {
GetComponentsInChildren(true, _components);
_transforms.Clear();
_audioSources.Clear();
_recorders.Clear();
_behaviours.Clear();
for (int i = 0; i < _components.Count; i++)
{
var component = _components[i];
if (component is Transform)
{
_transforms.Add(component as Transform);
}
if (component is AudioSource)
{
_audioSources.Add(component as AudioSource);
}
if (component is PropertyRecorder)
{
_recorders.Add(component as PropertyRecorder);
}
if (component is Behaviour)
{
_behaviours.Add(component);
}
if (component is Renderer)
{
_behaviours.Add(component);
}
if (component is Collider)
{
_behaviours.Add(component);
}
if (component is IValueProxy)
{
(component as IValueProxy).OnPullValue();
}
}
foreach (var transform in _transforms)
{
if (!_initialTransformData.ContainsKey(transform))
{
_initialTransformData[transform] = new TransformData()
{
localPosition = transform.localPosition,
localRotation = transform.localRotation,
localScale = transform.localScale,
enabled = transform.gameObject.activeSelf
};
}
}
foreach (var behaviour in _behaviours)
{
if (!_initialActivityData.ContainsKey(behaviour))
{
_initialActivityData[behaviour] = EditorUtility.GetObjectEnabled(behaviour) == 1;
}
}
switch (audioSourceMode)
{
case RecordingSelection.Nothing:
_audioSources.Clear();
break;
case RecordingSelection.Specific:
_audioSources.Clear();
_audioSources.AddRange(specificAudioSources);
break;
}
switch (transformMode)
{
case RecordingSelection.Nothing:
_transforms.Clear();
_behaviours.Clear();
break;
case RecordingSelection.Specific:
_transforms.Clear();
_transforms.AddRange(specificTransforms);
_behaviours.Clear();
foreach (var t in _transforms)
{
t.GetComponents(_tempBehaviour);
t.GetComponents(_tempRenderer);
t.GetComponents(_tempCollider);
foreach (var b in _tempBehaviour)
{
_behaviours.Add(b);
}
foreach (var b in _tempRenderer)
{
_behaviours.Add(b);
}
foreach (var b in _tempCollider)
{
_behaviours.Add(b);
}
}
break;
}
}
using (new ProfilerSample("Ensure Names Are Unique")) {
foreach (var transform in _transforms)
{
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
if (_takenNames.Contains(child.name))
{
child.name = child.name + " " + Mathf.Abs(child.GetInstanceID());
}
_takenNames.Add(child.name);
}
_takenNames.Clear();
}
}
using (new ProfilerSample("Discover Audio Sources")) {
//Update all audio sources
foreach (var source in _audioSources)
{
RecordedAudio data;
if (!_audioData.TryGetValue(source, out data))
{
data = source.gameObject.AddComponent <RecordedAudio>();
data.target = source;
data.recordingStartTime = _startTime;
_audioData[source] = data;
}
}
}
using (new ProfilerSample("Discover Property Recorders")) {
//Record all properties specified by recorders
foreach (var recorder in _recorders)
{
foreach (var bindings in recorder.GetBindings(gameObject))
{
if (!_curves.ContainsKey(bindings))
{
_curves[bindings] = new AnimationCurve();
}
}
}
}
using (new ProfilerSample("Record Custom Data")) {
foreach (var pair in _curves)
{
float value;
bool gotValue = AnimationUtility.GetFloatValue(gameObject, pair.Key, out value);
if (gotValue)
{
pair.Value.AddKey(Time.time - _startTime, value);
}
else
{
Debug.Log(pair.Key.path + " : " + pair.Key.propertyName + " : " + pair.Key.type.Name);
}
}
}
using (new ProfilerSample("Discover Transforms")) {
//Record ALL transform and gameObject data, no matter what
foreach (var transform in _transforms)
{
if (!_transformData.ContainsKey(transform))
{
_transformData[transform] = new List <TransformData>();
}
}
}
using (new ProfilerSample("Record Transform Data")) {
foreach (var pair in _transformData)
{
//If we have no data for this object BUT we also are not
//on the first frame of recording, this object must have
//been spawned, make sure to record a frame with it being
//disabled right before this
if (pair.Value.Count == 0 && Time.time > _startTime)
{
pair.Value.Add(new TransformData()
{
time = Time.time - _startTime - Time.deltaTime,
enabled = false,
localPosition = pair.Key.localPosition,
localRotation = pair.Key.localRotation,
localScale = pair.Key.localScale
});
}
pair.Value.Add(new TransformData()
{
time = Time.time - _startTime,
enabled = pair.Key.gameObject.activeInHierarchy,
localPosition = pair.Key.localPosition,
localRotation = pair.Key.localRotation,
localScale = pair.Key.localScale
});
}
}
using (new ProfilerSample("Discover Behaviours")) {
foreach (var behaviour in _behaviours)
{
if (!_behaviourActivity.ContainsKey(behaviour))
{
_behaviourActivity[behaviour] = new List <ActivityData>();
}
}
}
using (new ProfilerSample("Record Behaviour Activity Data")) {
foreach (var pair in _behaviourActivity)
{
//Same logic as above, if this is the first frame for a spawned
//object make sure to also record a disabled frame previously
if (pair.Value.Count == 0 && Time.time > _startTime)
{
pair.Value.Add(new ActivityData()
{
time = Time.time - _startTime - Time.deltaTime,
enabled = false
});
}
pair.Value.Add(new ActivityData()
{
time = Time.time - _startTime,
enabled = EditorUtility.GetObjectEnabled(pair.Key) == 1
});
}
}
if (provider != null && recordLeapData)
{
using (new ProfilerSample("Record Leap Data")) {
Frame newFrame = new Frame();
newFrame.CopyFrom(provider.CurrentFrame);
newFrame.Timestamp = (long)((Time.time - _startTime) * 1e6);
newFrame.Id = Time.frameCount - _startFrame;
_leapData.Add(newFrame);
}
}
}
public static void LerpLocalTransform(Transform t, TransformData data, float speed)
{
t.localPosition = Vector3.Lerp(t.localPosition, data.position, Time.deltaTime * speed);
t.localRotation = Quaternion.Lerp(t.localRotation, Quaternion.Euler(data.eulerAngles), Time.deltaTime * speed);
t.localScale = Vector3.Lerp(t.localScale, data.scale, Time.deltaTime * speed);
}
static extern void msServerServeTransform(IntPtr self, TransformData data);
/// <summary>
/// Updates the SyncedTransform property.
/// </summary>
public void UpdateTransformData()
{
SyncedTransform = new TransformData(transform);
}
void OnUpdateEntity(GameObject obj, TransformData data)
{
m_log += "GameObject: " + obj.name + "\n";
}
private void CreateScene()
{
List <Shape> allShapes = new List <Shape>(FindObjectsOfType <Shape>());
int numTransforms = FindObjectsOfType <AdvancedTransform>().Length;
int transformIndex = 0;
ShapeData[] shapeData;
TransformData[] transformData = null;
if (allShapes.Count > 0)
{
shapeData = new ShapeData[allShapes.Count];
if (numTransforms > 0)
{
transformData = new TransformData[numTransforms];
}
for (int i = 0; i < allShapes.Count; i++)
{
Shape s = allShapes[i];
Vector3 col = new Vector3(s.color.r, s.color.g, s.color.b);
Matrix4x4 transformationMatrix = (Matrix4x4.Translate(s.Position) * Matrix4x4.Rotate(s.Rotation)).inverse;
List <AdvancedTransform> shapeTransforms = new List <AdvancedTransform>(s.GetComponentsInParent <AdvancedTransform>());
shapeData[i] = new ShapeData()
{
transformation = transformationMatrix,
scale = new Vector3(Mathf.Abs(s.Scale.x), Mathf.Abs(s.Scale.y), Mathf.Abs(s.Scale.z)),
color = col,
shapeType = (int)s.shapeType,
numTransforms = shapeTransforms.Count,
roughness = s.roughness,
metalness = s.metalness
};
if (shapeTransforms.Count > 0)
{
foreach (AdvancedTransform t in shapeTransforms)
{
transformData[transformIndex] = new TransformData()
{
transformType = (int)t.transformType,
scale = t.scale
};
transformIndex++;
}
}
}
rayMarchingShader.SetInt("numShapes", shapeData.Length);
}
else
{
shapeData = new ShapeData[1];
rayMarchingShader.SetInt("numShapes", 0);
}
if (numTransforms == 0)
{
transformData = new TransformData[1];
}
ComputeBuffer shapeBuffer = new ComputeBuffer(shapeData.Length, ShapeData.GetSize());
shapeBuffer.SetData(shapeData);
rayMarchingShader.SetBuffer(0, "shapes", shapeBuffer);
buffersToDispose.Add(shapeBuffer);
ComputeBuffer transformBuffer = new ComputeBuffer(transformData.Length, TransformData.GetSize());
transformBuffer.SetData(transformData);
rayMarchingShader.SetBuffer(0, "advancedTransforms", transformBuffer);
buffersToDispose.Add(transformBuffer);
}
public void ServeTransform(TransformData data)
{
msServerServeTransform(self, data);
}
/// <summary>
/// Attempts to retrieve the <see cref="GameObject"/> from a given <see cref="TransformData"/>.
/// </summary>
/// <param name="transformData">The <see cref="TransformData"/> to retrieve the <see cref="GameObject"/> from.</param>
/// <returns>The <see cref="GameObject"/> if one exists on the given <see cref="TransformData"/>.</returns>
public static GameObject TryGetGameObject(this TransformData transformData)
{
return(transformData?.Transform == null ? null : transformData.Transform.gameObject);
}
[DllImport(Lib.name)] static extern void msServerServeTransform(IntPtr self, TransformData data);
protected override Size ArrangeOverride(Size finalSize)
{
Projection = myPlaneProjection = new PlaneProjection { RotationX = -30, LocalOffsetZ = -500, LocalOffsetY = -finalSize.Height / 2 };
const double scale = 1.35;
myTranslateTransform = new TranslateTransform { X = 0, Y = 0 };
myScaleTransform = new ScaleTransform { ScaleX = scale, ScaleY = scale, CenterX = finalSize.Width / 2, CenterY = finalSize.Height / 2 };
var transformGroup = new TransformGroup();
transformGroup.Children.Add(myTranslateTransform);
transformGroup.Children.Add(myScaleTransform);
RenderTransform = transformGroup;
myCurrentTransformData = new TransformData(myPlaneProjection, myTranslateTransform, myScaleTransform);
return base.ArrangeOverride(finalSize);
}
/// <summary>
/// Attempts to teleport the <see cref="playAreaAlias"/>.
/// </summary>
/// <param name="destination">The location to attempt to teleport to.</param>
public virtual void Teleport(TransformData destination)
{
internalSetup?.Teleport(destination);
}
private TransformData AnimateTo(double centerX, double rectCenterX, double centerY, double rectCenterY, double scale)
{
var savedTransform = new TransformData(myCurrentTransformData.PlaneProjection, myCurrentTransformData.TranslateTransform, myCurrentTransformData.ScaleTransform);
var newTranslateTransform = new TranslateTransform {X = centerX - rectCenterX, Y = centerY - rectCenterY};
var newScaleTransform = new ScaleTransform{ScaleX = scale, ScaleY = scale, CenterX = centerX, CenterY = centerY};
var newPlaneProjection = new PlaneProjection();
Animate(newTranslateTransform, newScaleTransform, newPlaneProjection, new PowerEase {Power = 5});
return savedTransform;
}
internal DbTransform(TransformData data) :
this(data.X, data.Y, MathHelper.ToRadians(data.SkX), data.scX, data.scY)
{
}
public static Vector2 RotateUV(Vector2 source, TransformData transformData)
{
return transformData.Vector + (source - transformData.Vector).Rotate(transformData.Float1);
}
public static Vector2 ScaleUV(Vector2 source, TransformData transformData)
{
return new Vector2(source.x * transformData.Vector.x, source.y * transformData.Vector.y);
}
/// <summary>
/// Attempts to teleport the <see cref="Target"/>.
/// </summary>
/// <param name="destination">The location to attempt to teleport to.</param>
public virtual void Teleport(TransformData destination)
{
Configuration.Teleport(destination);
}
public static TransformData Interpolate(TransformData current, Transform target, float fac, Space space = Space.Self)
{
return Interpolate(current, new TransformData(target), fac);
}
void Awake()
{
this.color = GetComponent<Renderer>().sharedMaterial.color;
this.OriginalTranform = new TransformData(this.transform);
}
private void Update()
{
if (guns == null)
{
return;
}
currentGun = guns.SelectedGun();
int gunControllerStatus = (int)guns.status;
//If we are Reloading, Aiming, Swapping, or Taking Out a gun
if ((currentGun != null && currentGun.status == GunHandler.GunStatus.reloading) || (gunControllerStatus >= 1 && gunControllerStatus <= 3))
{
UpdateStatus(IKStatus.weaponIK);
}
else
{
int playerControllerStatus = (int)playerStatus;
if (playerControllerStatus == 11) //underwater swimming
{
UpdateStatus(IKStatus.animatedIK);
}
else if (playerControllerStatus >= 4 && playerControllerStatus <= 10) //sliding, climbingLadder, wallRunning, vaulting, grabbedLedge, climbingLedge, or surface swimming
{
UpdateStatus(IKStatus.lockedIK);
}
else
{
UpdateStatus(IKStatus.weaponIK);
}
}
IKData lockedIK = null;
TransformData data = new TransformData(player.transform);
if (IKStatus == IKStatus.lockedIK && lockedData != null)
{
data = (lockedIK = lockedData.Invoke()).HandData();
}
TransformHelper.LerpTransform(lockedIKTarget, data, 16f);
switch (IKStatus)
{
case IKStatus.weaponIK:
if (currentGun != null && guns.status != GunController.GunControlStatus.swapping)
{
UpdateTarget(currentGun.handIKTarget);
}
Vector3 armAimPos = defaultArmPos;
armAimPos.z = guns.isAiming() ? aimArmZ : defaultArmPos.z;
armIK.transform.localPosition = Vector3.Lerp(armIK.transform.localPosition, armAimPos, Time.deltaTime * 12f);
armIK.elbow.localPosition = Vector3.Lerp(armIK.elbow.localPosition, defaultElbowPos, Time.deltaTime * 12f);
break;
case IKStatus.animatedIK:
UpdateTarget(animatedIKTarget.transform);
animatedIKTarget.SetInteger("playerStatus", (int)playerStatus);
armIK.transform.localPosition = Vector3.Lerp(armIK.transform.localPosition, defaultArmPos, Time.deltaTime * 12f);
armIK.elbow.localPosition = Vector3.Lerp(armIK.elbow.localPosition, defaultElbowPos, Time.deltaTime * 12f);
break;
case IKStatus.lockedIK:
UpdateTarget(lockedIKTarget);
if (lockedIK != null)
{
armIK.transform.localPosition = Vector3.Lerp(armIK.transform.localPosition, lockedIK.armLocalPos, Time.deltaTime * 12f);
armIK.elbow.position = Vector3.Lerp(armIK.elbow.position, lockedIK.armElbowPos, Time.deltaTime * 12f);
}
break;
}
}
protected abstract void InverseTransform(ref TransformData data);
public void DefaultConstructor()
{
TransformData transformData = new TransformData();
Assert.IsNull(transformData.Transform);
}
public SqliteFunctionTransform(TransformData dbsh)
{
_dbsh = dbsh;
}
void NewClient()
{
TcpClient temp = listener.AcceptTcpClient();
NetworkStream nsSelf = temp.GetStream();
IPEndPoint ipep = (IPEndPoint)temp.Client.RemoteEndPoint;
GameObject player = new GameObject(ipep.ToString())
{
tag = ipep.ToString()
};
GameObject character = (GameObject)Instantiate(playerPrefab, spawnPoint.transform.position, spawnPoint.transform.rotation, player.transform);
PlayerControlRemote pcr = character.GetComponent <PlayerControlRemote>();
//clientTCP.Add(temp);
//ns.Add(nsSelf);
//players.Add(player);
if (clients.Count < 7)
{
new Thread(NewClient).Start();
}
while (true)
{
var buffer = new byte[Marshal.SizeOf(typeof(TransformData))];
int recved = 0;
while ((recved = nsSelf.Read(buffer, 0, buffer.Length)) > 0)
{
BinaryFormatter formatter = new BinaryFormatter();
TransformData recvData = (TransformData)formatter.Deserialize(nsSelf);
pcr.SetTransforms(recvData);
}
}
temp.Close();
//while (true)
//{
// IPEndPoint epRemote = new IPEndPoint(IPAddress.Any, 0);
// UdpClient udpCli = new UdpClient();
// byte[] bytes = udpCli.Receive(ref epRemote);
// if (bytes != null)
// {
// bool newOne = true;
// //int num = 0;
// int temp = 0;
// foreach (ClientData c in clients)
// {
// if (c.ip == epRemote)
// {
// newOne = false;
// }
// temp++;
// }
// if (newOne == true && clients.Count < 8)
// {
// ClientData cd = new ClientData
// {
// ip = epRemote,
// state = true,
// name = "Player" + clientCount++.ToString(),
// //sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
// };
// clients.Add(cd);
// Thread tTemp = new Thread(new ParameterizedThreadStart(RecvNSendFunc));
// tTemp.Start(cd);
// tRecv.Add(tTemp);
// }
// }
// Thread.Sleep(5);
//}
}
protected override void InverseTransform(ref TransformData data)
{
double x = data.X;
double y = data.Y;
double ix = x * scaleR;
double iy = y * scaleR;
double bumpAngle = this.theta * PerlinNoise2D.Noise(ix, iy, this.detail, this.roughness, this.seed);
data.X = x + (this.refractionScale * Math.Sin(-bumpAngle));
data.Y = y + (this.refractionScale * Math.Cos(bumpAngle));
}
public void TryGetGameObjectInvalid()
{
TransformData invalid = new TransformData();
Assert.IsNull(invalid.TryGetGameObject());
}
bool IsFinite(TransformData t)
{
return IsFinite (t.position) && IsFinite (t.rotation);
}
public static Vector2 FlipUVX(Vector2 source, TransformData transformData)
{
source.x = 1-source.x;
return source;
}
