//
    public static List <TransitionInfo> GetTransitionPath(List <TransitionInfo> fromPath, List <TransitionInfo> toPath)
    {
        List <TransitionInfo> newPath = new List <TransitionInfo>();
        int len = toPath.Count;

        // 同じScneControllerを探し、新しくPathを作成
        for (int i = len - 1; i >= 0; i--)
        {
            TransitionInfo  toScAndId         = toPath[i];
            SceneController toSceneController = toScAndId.controller;
            //
            for (int j = fromPath.Count - 1; j >= 0; j--)
            {
                TransitionInfo  fromScAndId         = fromPath[j];
                SceneController fromSceneController = fromScAndId.controller;

                if (toSceneController == fromSceneController)
                {
                    int from_index = j;
                    int to_index   = i;

                    fromPath.RemoveRange(0, from_index + 1);
                    fromPath.Reverse();
                    newPath.AddRange(fromPath);

                    toPath.RemoveRange(0, to_index);
                    newPath.AddRange(toPath);
                    return(newPath);
                }
            }
        }
        return(null);
    }
    public static void TransitionContent(List <TransitionInfo> toRootScenes, int index)
    {
        TransitionInfo setScene = toRootScenes [index];

        SceneController controller = setScene.controller;
        int             sceneId    = setScene.sceneId;

        SceneController.TransitionHandler handler = null;
        handler = delegate(SceneBase s, SceneController.TransitionType transitionType) {
            if (transitionType == SceneController.TransitionType.OPEN_COMP)
            {
                controller.eventTransition -= handler;
                controller.isAutoTransition = false;

                index++;
                if (index < toRootScenes.Count)
                {
                    TransitionContent(toRootScenes, index);
                }
                else
                {
                    return;
                }
            }
        };
        controller.eventTransition += handler;
        Debug.Log("Trans: " + controller + " / " + sceneId);

        controller.isAutoTransition = true;
        controller.TransitionScene(sceneId);
    }
示例#3
0
        private void Setup3DScene(TransitionInfo transitionInfo)
        {
            // Create the viewport that will host the 3D animation
            Viewport3D = new Viewport3D {
                IsHitTestVisible = false, ClipToBounds = false
            };

            // Set up the camera
            Camera            = CreateCamera(transitionInfo);
            Viewport3D.Camera = Camera;

            // Set up the light
            Light = CreateLight(transitionInfo);
            Viewport3D.Children.Add(Light);

            // Set up the 3D objects
            var objects = Create3DObjects(transitionInfo);

            objects.ForEach(m => Viewport3D.Children.Add(m));

            transitionInfo.Scene.Children.Add(Viewport3D);

            // Hides views
            if (transitionInfo.BackView != null)
            {
                transitionInfo.BackView.Visibility = Visibility.Hidden;
            }
            if (transitionInfo.FrontView != null)
            {
                transitionInfo.FrontView.Visibility = Visibility.Hidden;
            }
        }
示例#4
0
        private Storyboard HideFrontViewAnimation(TransitionInfo transitionInfo)
        {
            var storyboard = new Storyboard();

            var translateTransform = new TranslateTransform();

            transitionInfo.SceneNameScope.RegisterName(AnimatedObjectName, translateTransform);

            transitionInfo.FrontView.RenderTransform = translateTransform;

            var slideAnimation = new DoubleAnimation
            {
                From           = 0,
                To             = -1 * transitionInfo.FrontView.ActualWidth,
                Duration       = Duration,
                EasingFunction = new CubicEase()
            };

            Storyboard.SetTargetName(slideAnimation, AnimatedObjectName);
            Storyboard.SetTargetProperty(slideAnimation, new PropertyPath(TranslateTransform.XProperty));

            storyboard.Children.Add(slideAnimation);

            return(storyboard);
        }
            /// <summary>
            /// Adds transition information to the object.
            /// Only used internally in <see cref="ITransitiontInfo.AddTo(GameObject)"/>.
            /// </summary>
            /// <param name="info">Transition informaion to add</param>
            /// <returns><see cref="TransitionResult"/> that contains the state of the transition</returns>
            public TransitionResult AddInfo(ITransitiontInfo info)
            {
                TransitionInfo information = new TransitionInfo();

                information.info = info;
                TransitionResult result = new TransitionResult();

                information.result = result;

                if (information.info.IsPhysics)
                {
                    physicsInfos.Add(information);
                }
                else
                {
                    nonphysicsInfos.Add(information);
                }

                if (!enabled)
                {
                    enabled = true;
                }

                return(result);
            }
示例#6
0
    private void Start()
    {
        canvas.GetComponent <Canvas>().worldCamera        = mainCamera;
        overlayCanvas.GetComponent <Canvas>().worldCamera = mainCamera;

        universalCanvas = GameObject.FindGameObjectWithTag("Canvas");

        networkDiscovery = FindObjectOfType <NetworkDiscovery>();

        gameManager        = FindObjectOfType <GameManager>();
        sceneChangeManager = FindObjectOfType <SceneChangeManager>();
        transitionInfo     = FindObjectOfType <TransitionInfo>();
        audioManager       = FindObjectOfType <AudioManager>();

        infoPanel = FindObjectOfType <InfoPanel>();

        x = gameManager.x;
        o = gameManager.o;

        ScaleUpFinished       += ScaleDone;
        DotsScaleDownFinished += DisbaleDotsAndReset;

        ModifiedNetworkManager.OnServerDisconnected += ServerDisconnected;
        ModifiedNetworkManager.OnClientDisconnected += ClientDisconnected;
    }
示例#7
0
        /// <summary>
        /// </summary>
        /// <param name="inputData"></param>
        public void Enable(ICollection <Dictionary <string, object> > inputData)
        {
            RequireActivation(true);
            //TODO: validate the data
            if (inputData.Count == 0)
            {
                throw new TaskDataInvalidException(TaskId, InstanceId, "No input data for multi-instance task");
            }
            this.Status = TaskStatus.Enabling;
            foreach (Dictionary <string, object> dob in inputData)
            {
                TransitionInfo ti = new TransitionInfo();
                ti.Status     = TransitionStatus.Enabling;
                ti.InstanceId = AllocateNewTaskInstanceId(TaskId);
                ChildTransitions.Add(ti);

                Context.EnableChildTask(new EnableChildTask {
                    CorrelationId         = ti.InstanceId,
                    FromProcessInstanceId = this.ProcessInstanceId,
                    FromTaskInstanceId    = this.InstanceId,
                    ToTaskInstanceId      = ti.InstanceId,
                    InputData             = dob,
                    ProcessDefinitionId   = this.ProcessDefinitionId,
                    TaskId = this.TaskId
                });
            }
        }
            private static void ParseEventHandler(CompositeActivity eventHandler, List <TransitionInfo> transitions)
            {
                Queue <Activity> processingQueue = new Queue <Activity>();

                processingQueue.Enqueue(eventHandler);
                while (processingQueue.Count > 0)
                {
                    Activity         activity = processingQueue.Dequeue();
                    SetStateActivity setState = activity as SetStateActivity;
                    if (setState != null)
                    {
                        TransitionInfo transitionInfo = new TransitionInfo(setState, eventHandler);
                        transitions.Add(transitionInfo);
                    }
                    else
                    {
                        CompositeActivity compositeActivity = activity as CompositeActivity;
                        if (compositeActivity != null)
                        {
                            foreach (Activity childActivity in compositeActivity.Activities)
                            {
                                processingQueue.Enqueue(childActivity);
                            }
                        }
                    }
                }
            }
示例#9
0
        private void Handle(TaskEnabled message)
        {
            RequireActivation(true);
            TransitionInfo ti = GetTransition(message.FromTaskInstanceId);

            if (ti == null)
            {
                ti = GetTransition(message.CorrelationId);
            }
            if (ti == null)
            {
                throw new TaskRuntimeException("Child transition not found: " + message.CorrelationId).SetInstanceId(InstanceId);
            }
            if (ti.Status == TransitionStatus.Enabling)
            {
                log.Info("MT Child transition {0} has been enabled", ti.InstanceId);
                ti.Status = TransitionStatus.Enabled;
                if (ti.InstanceId != message.FromTaskInstanceId)
                {
                    log.Info("Child task instance id changed {0}->{1}", ti.InstanceId, message.FromTaskInstanceId);
                    ti.InstanceId = message.FromTaskInstanceId;
                }
                OnTransitionStatusChanged(ti.InstanceId);
            }
            else
            {
                log.Debug("Ignoring message: {0}", message);
            }
        }
        public IEntityWorkflowTransition Transition(string commandName)
        {
            IEntityWorkflowTransition result = new TransitionInfo(commandName);

            _transitions.Add(result);
            return(result);
        }
示例#11
0
 public LayoutDrawElement(Location location, BitmapEx bitmap, TransitionInfo transitionInfo = default(TransitionInfo))
 {
     Location             = location;
     TransitionInfo       = transitionInfo;
     BitmapRepresentation = new BitmapRepresentation(bitmap);
     bitmap.Dispose();
 }
示例#12
0
        public static void ProcessAllTransitions(Animator animator, ProcessAnimatorTransition callback)
        {
            AnimatorController controller = GetInternalAnimatorController(animator);
            int layerCount = controller.layerCount;

            for (int layer = 0; layer < layerCount; layer++)
            {
                string layerName = controller.GetLayer(layer).name;
                UnityEditorInternal.StateMachine sm = controller.GetLayer(layer).stateMachine;
                //Handle anyState cases. see UnityEditorInternal.StateMachine.transitions
                {
                    Transition[] anyTransitions = sm.GetTransitionsFromState(null);
                    foreach (var t in anyTransitions)
                    {
                        TransitionInfo info = new TransitionInfo(t.uniqueNameHash, t.uniqueName, layer, layerName,
                                                                 0, t.dstState.uniqueNameHash, t.atomic, t.duration, t.mute, t.offset, t.solo);
                        callback(info);
                    }
                }
                for (int i = 0; i < sm.stateCount; i++)
                {
                    UnityEditorInternal.State state = sm.GetState(i);
                    Transition[] transitions        = sm.GetTransitionsFromState(state);
                    foreach (var t in transitions)
                    {
//						Debug.Log (state.uniqueName +  ", transition: " + t.uniqueName + " ---" + " dest = " + t.dstState + " (" + (Animator.StringToHash (state.uniqueName) == Animator.StringToHash (layerName + "." + t.dstState)) + ") " + " src = " + t.srcState);
                        TransitionInfo info = new TransitionInfo(t.uniqueNameHash, t.uniqueName, layer, layerName,
                                                                 t.srcState.uniqueNameHash, t.dstState.uniqueNameHash, t.atomic, t.duration, t.mute, t.offset, t.solo);
                        callback(info);
                    }
                }
            }
        }
示例#13
0
        protected override Camera CreateCamera(TransitionInfo transitionInfo)
        {
            var axisAngle = new AxisAngleRotation3D(new Vector3D(0, 1, 0), 0);

            transitionInfo.SceneNameScope.RegisterName(AnimatedObjectName, axisAngle);

            var camera = new PerspectiveCamera
            {
                LookDirection = new Vector3D(0, 0, -1),
                Transform     = new RotateTransform3D(axisAngle)
            };

            // Compute camera position
            const double fieldOfView       = 30d;
            const double fieldOfViewRadian = (fieldOfView / 2d) * (Math.PI / 180f);

            var oppositeSideLength         = transitionInfo.SceneWidth / 2d;
            var computedOppositeSideLength = oppositeSideLength * Math.Tan(fieldOfViewRadian) + oppositeSideLength;
            var cameraDistance             = computedOppositeSideLength / Math.Tan(fieldOfViewRadian);

            camera.FieldOfView = fieldOfView;
            camera.Position    = new Point3D(0, 0, cameraDistance);

            return(camera);
        }
示例#14
0
        protected override List <ModelVisual3D> Create3DObjects(TransitionInfo transitionInfo)
        {
            var initiallyVisibleView = transitionInfo.AnimationType == AnimationType.ShowFrontView
                                           ? transitionInfo.BackView
                                           : transitionInfo.FrontView;

            var initiallyInvisibleView = transitionInfo.AnimationType == AnimationType.ShowFrontView
                                           ? transitionInfo.FrontView
                                           : transitionInfo.BackView;

            return(new List <ModelVisual3D>
            {
                new ModelVisual3D
                {
                    Content = new GeometryModel3D
                    {
                        Material = CreateInitiallyVisibleFaceMaterial(initiallyVisibleView),
                        Geometry = CreateInitiallyVisibleFaceMesh(initiallyVisibleView)
                    }
                },
                new ModelVisual3D
                {
                    Content = new GeometryModel3D
                    {
                        Material = CreateInitiallyInvisibleFaceMaterial(initiallyInvisibleView),
                        Geometry = CreateInitiallyInvisibleFaceMesh(initiallyInvisibleView)
                    }
                }
            });
        }
示例#15
0
    // Start is called before the first frame update
    void Start()
    {
        transitionInfo = FindObjectOfType <TransitionInfo>();

        if (transitionInfo == null)
        {
            Debug.LogWarning("TransitionInfo was not found!");
        }

        if (transitionInfo.overrideParamaters)
        {
            return;
        }

        #region  Startup in Some Scenes

        if ((transitionInfo.canceledHost || transitionInfo.returningFromWin) && SceneManager.GetActiveScene().name == "Main")
        {
            fadePanel.GetComponent <Image>().color = new Color(0f, 0f, 0f, 1f);
            fadePanel.SetActive(true);

            transitionInfo.Reset();

            StartCoroutine(FadePanel(1));
        }

        if (SceneManager.GetActiveScene().name.Equals("Win"))
        {
            fadePanel.GetComponent <Image>().color = new Color(0f, 0f, 0f, 1f);
            fadePanel.SetActive(true);
            StartCoroutine(FadePanel(2));
        }

        #endregion
    }
示例#16
0
 private void OnPreviewAvatarChanged()
 {
     this.m_RefTransitionInfo = new TransitionInfo();
     this.ClearController();
     this.CreateController();
     this.CreateParameterInfoList();
 }
示例#17
0
        /// <summary>
        /// Starts the fade screen transition animation
        /// </summary>
        private void StartFadeAnimation(TransitionInfo transitionInfo, bool show, float duration)
        {
            float fromAlpha = show ? 0f : 1f;
            float toAlpha   = show ? 1f : 0f;

            UIAnimation anim = UIAnimation.Alpha(gameObject, fromAlpha, toAlpha, duration);

            anim.style             = transitionInfo.animationStyle;
            anim.animationCurve    = transitionInfo.animationCurve;
            anim.startOnFirstFrame = true;

            if (!show)
            {
                anim.OnAnimationFinished = (GameObject obj) =>
                {
                    SetVisibility(false);
                };
            }
            else
            {
                anim.OnAnimationFinished = null;
            }

            anim.Play();
        }
示例#18
0
        private void AddEdge(XElement graph, TransitionInfo<TState, TEvent> transition)
        {
            string actions = CreateActionsDescription(transition);
            string guard = CreateGuardDescription(transition);

            string arrow;
            string lineStyle;
            string targetId;
            if (transition.Target != null)
            {
                arrow = "standard";
                lineStyle = "line";
                targetId = transition.Target.Id.ToString();
            }
            else
            {
                arrow = "plain";
                lineStyle = "dashed";
                targetId = transition.Source.Id.ToString();
            }

            var edge = new XElement(
                N + "edge", 
                new XAttribute("id", transition.EventId + (this.edgeId++).ToString(CultureInfo.InvariantCulture)), 
                new XAttribute("source", transition.Source.Id), 
                new XAttribute("target", targetId));
 
            edge.Add(new XElement(
                N + "data", 
                new XAttribute("key", "d10"), 
                new XElement(Y + "PolyLineEdge", new XElement(Y + "LineStyle", new XAttribute("type", lineStyle)), new XElement(Y + "Arrows", new XAttribute("source", "none"), new XAttribute("target", arrow)), new XElement(Y + "EdgeLabel", guard + transition.EventId + actions))));
            
            graph.Add(edge);
        }
示例#19
0
        private void Handle(TaskCancelled message)
        {
            RequireActivation(true);
            if (message.ParentTaskInstanceId != this.InstanceId)
            {
                throw new Exception();
            }
            TransitionInfo ti = GetTransition(message.FromTaskInstanceId);

            if (ti == null)
            {
                throw new Exception();
            }
            lock (this)
            {
                log.Info("Child task {0} has been cancelled", ti.InstanceId);
                if (ti.Status == TransitionStatus.Cancelled)
                {
                    return;
                }
                if (!ti.IsTransitionActive)
                {
                    log.Warn("Transition {0} ({1}) is not active: {2}", ti.InstanceId, ti.TaskId, ti.Status);
                    return;
                }
                ti.Status = TransitionStatus.Cancelled;
                OnTransitionStatusChanged(ti.InstanceId);
                return;
            }
        }
 public bool IsEqual(TransitionInfo info)
 {
     return(m_SrcState == info.m_SrcState &&
            m_DstState == info.m_DstState &&
            Mathf.Approximately(m_TransitionDuration, info.m_TransitionDuration) &&
            Mathf.Approximately(m_TransitionOffset, info.m_TransitionOffset) &&
            Mathf.Approximately(m_ExitTime, info.m_ExitTime));
 }
    // Start is called before the first frame update
    void Start()
    {
        transitionInfo     = FindObjectOfType <TransitionInfo>();
        sceneChangeManager = FindObjectOfType <SceneChangeManager>();
        aumanager          = FindObjectOfType <AudioManager>();
        networkDiscovery   = FindObjectOfType <NetworkDiscovery>();

        SceneChangeManager.OnStopHostingCancel += CancelAndStopHosting;
    }
        public ITransitionInfo Create(IDictionary <string, object> transitionInfo)
        {
            var t = new TransitionInfo
            {
                Source     = (string)transitionInfo["source"],
                Target     = (string)transitionInfo["target"],
                Transition = (string)transitionInfo["transition"]
            };

            return(t);
        }
示例#23
0
        private void start <TScene>(Color clearColor) where TScene : Scene, new()
        {
            var transition = new FadeTransition(() => Scene.createWithDefaultRenderer <TScene>(clearColor))
            {
                delayBeforeFadeInDuration = 0, fadeOutDuration = duration,
                fadeInDuration            = duration, fadeToColor = clearColor
            };
            var next = new TransitionInfo(transition, typeof(TScene));

            this.enqueue(next);
        }
示例#24
0
        private void ProcessEvents(Event current)
        {
            switch (current.type)
            {
            case EventType.MouseDown:
                bool transitionSelected = false;
                foreach (var item in _transitionRectList)
                {
                    if (item.Rect.Contains(current.mousePosition - new Vector2(0, _menuAreaRect.height) + _scrollPositon))
                    {
                        transitionSelected  = true;
                        _selectedTransition = item;
                        if (_selectedNode != null)
                        {
                            _selectedNode.IsSelected = false;
                            _selectedNode            = null;
                        }
                        GUI.changed = true;
                        break;
                    }
                }
                switch (current.button)
                {
                case 1:
                    if (_selectedNode == null)
                    {
                        if (transitionSelected)
                        {
                            _selectedTransitionContextMenu.ShowAsContext();
                        }
                        else
                        {
                            _addStateContextMenu.ShowAsContext();
                        }
                    }
                    else
                    {
                        _selectedNodeContextMenu.ShowAsContext();
                    }
                    break;
                }

                _currentMousePossition = current.mousePosition;
                break;

            case EventType.MouseDrag:
                if (current.button == 2)
                {
                    _scrollPositon -= current.delta;
                    Repaint();
                }
                break;
            }
        }
示例#25
0
        public void SetTransition(AnimatorStateTransition transition, AnimatorState sourceState, AnimatorState destinationState, AnimatorControllerLayer srcLayer, Animator previewObject)
        {
            this.m_RefSrcState = sourceState;
            this.m_RefDstState = destinationState;
            TransitionInfo info = new TransitionInfo();

            info.Set(transition, sourceState, destinationState);
            if (this.MustResample(info))
            {
                this.ResampleTransition(transition, srcLayer.avatarMask, info, previewObject);
            }
        }
示例#26
0
        public void AddTransitionFrom(TransitionInfo transitionInfo)
        {
            var source = StateNodeOf(transitionInfo.StateFrom);
            var target = StateNodeOf(transitionInfo.StateTo);

            var newTransition = new TransitionConnection(source, target, _builder.TriggerType, transitionInfo.Trigger, transitionInfo.GuardConditions);

            newTransition.OnTriggerChanged         += (connection, previousTrigger, currentTrigger) => RecordAndRebuild();
            newTransition.OnGuardConditionsChanged += (connection, currentGuardConditions) => RecordAndRebuild();

            _transitions.Add(newTransition);
        }
示例#27
0
        void Start()
        {
            networkManager     = FindObjectOfType <ModifiedNetworkManager>();
            networkDiscovery   = FindObjectOfType <NetworkDiscovery>();
            transitionInfo     = FindObjectOfType <TransitionInfo>();
            sceneChangeManager = FindObjectOfType <SceneChangeManager>();
            aumanager          = FindObjectOfType <AudioManager>();

            SceneChangeManager.OnStopHostingCancel += CancelAndStopHosting;

            LeanTween.scale(glass, new Vector3(1.1f, 1.1f, 1.1f), 2f).setEaseInOutSine().setLoopPingPong();
        }
示例#28
0
        protected override Storyboard CreateAnimation(TransitionInfo transitionInfo)
        {
            var storyboard = new Storyboard();

            Point3DAnimationUsingKeyFrames cameraPositionAnimation;
            DoubleAnimationUsingKeyFrames  cameraRotationAnimation;

            // Camera distance animation
            cameraPositionAnimation = new Point3DAnimationUsingKeyFrames {
                Duration = Duration
            };
            cameraPositionAnimation.KeyFrames.Add(new EasingPoint3DKeyFrame(_cameraInitialPosition, KeyTime.FromPercent(0)));
            cameraPositionAnimation.KeyFrames.Add(new EasingPoint3DKeyFrame(_cameraIntermediatePosition, KeyTime.FromPercent(0.25)));
            cameraPositionAnimation.KeyFrames.Add(new EasingPoint3DKeyFrame(_cameraIntermediatePosition, KeyTime.FromPercent(0.75)));
            cameraPositionAnimation.KeyFrames.Add(new EasingPoint3DKeyFrame(_cameraInitialPosition, KeyTime.FromPercent(1)));

            Storyboard.SetTargetName(cameraPositionAnimation, CameraObjectName);
            Storyboard.SetTargetProperty(cameraPositionAnimation, new PropertyPath(ProjectionCamera.PositionProperty));

            // Flip animation

            switch (Direction)
            {
            case FlipDirection.LeftToRight:
            case FlipDirection.BottomToTop:
                cameraRotationAnimation = new DoubleAnimationUsingKeyFrames {
                    Duration = Duration
                };
                cameraRotationAnimation.KeyFrames.Add(new EasingDoubleKeyFrame(0, KeyTime.FromPercent(0.25)));
                cameraRotationAnimation.KeyFrames.Add(new EasingDoubleKeyFrame(-180, KeyTime.FromPercent(0.75)));
                cameraRotationAnimation.KeyFrames.Add(new EasingDoubleKeyFrame(-180, KeyTime.FromPercent(1)));
                break;

            default:
                cameraRotationAnimation = new DoubleAnimationUsingKeyFrames {
                    Duration = Duration
                };
                cameraRotationAnimation.KeyFrames.Add(new EasingDoubleKeyFrame(0, KeyTime.FromPercent(0.25)));
                cameraRotationAnimation.KeyFrames.Add(new EasingDoubleKeyFrame(180, KeyTime.FromPercent(0.75)));
                cameraRotationAnimation.KeyFrames.Add(new EasingDoubleKeyFrame(180, KeyTime.FromPercent(1)));
                break;
            }

            Storyboard.SetTargetName(cameraRotationAnimation, CameraRotationObjectName);
            Storyboard.SetTargetProperty(cameraRotationAnimation, new PropertyPath(AxisAngleRotation3D.AngleProperty));

            storyboard.Children.Add(cameraPositionAnimation);
            storyboard.Children.Add(cameraRotationAnimation);

            return(storyboard);
        }
        /// <summary>
        /// Adds a property to the schema.
        /// </summary>
        /// <param name="name"> The name of the property to add. </param>
        /// <param name="attributes"> The property attributes. </param>
        /// <returns> A new schema with the extra property. </returns>
        public HiddenClassSchema AddProperty(string name, PropertyAttributes attributes)
        {
            // Package the name and attributes into a struct.
            var transitionInfo = new TransitionInfo {
                Name = name, Attributes = attributes
            };

            // Check if there is a transition to the schema already.
            HiddenClassSchema newSchema = null;

            if (this.m_addTransitions != null)
            {
                this.m_addTransitions.TryGetValue(transitionInfo, out newSchema);
            }

            if (newSchema == null)
            {
                if (this.m_parent == null)
                {
                    // Create a new schema based on this one.  A complete copy must be made of the properties hashtable.
                    var properties = new Dictionary <string, SchemaProperty>(this.m_properties)
                    {
                        { name, new SchemaProperty(this.NextValueIndex, attributes) }
                    };
                    newSchema = new HiddenClassSchema(properties, this.NextValueIndex + 1, this, transitionInfo);
                }
                else
                {
                    // Create a new schema based on this one.  The properties hashtable is "given
                    // away" so a copy does not have to be made.
                    if (this.m_properties == null)
                    {
                        this.m_properties = CreatePropertiesDictionary();
                    }
                    this.m_properties.Add(name, new SchemaProperty(this.NextValueIndex, attributes));
                    newSchema         = new HiddenClassSchema(this.m_properties, this.NextValueIndex + 1, this, transitionInfo);
                    this.m_properties = null;
                }


                // Add a transition to the new schema.
                if (this.m_addTransitions == null)
                {
                    this.m_addTransitions = new Dictionary <TransitionInfo, HiddenClassSchema>(1);
                }
                this.m_addTransitions.Add(transitionInfo, newSchema);
            }

            return(newSchema);
        }
示例#30
0
        /// <summary>
        /// 将 link 信息转化成 info 信息
        /// </summary>
        /// <param name="link"></param>
        /// <returns></returns>
        public static TransitionInfo ExtractTransitionInfo(ActivityLink link)
        {
            TransitionInfo tranInfo = new TransitionInfo()
            {
                Key             = link.Key,
                Name            = link.Text,
                Enabled         = link.WfEnabled,
                FromActivityKey = link.From,
                ToActivityKey   = link.To,
                IsReturn        = link.WfReturnLine
            };

            return(tranInfo);
        }
示例#31
0
 private static void InvestigateDetails(FileInfo fileInfo, TextWriter trace, TimeSpan totalDuration)
 {
     using (var reader = fileInfo.OpenText())
     {
         DateTime previousPointInTime = DateTime.Now;
         string previousLine = string.Empty;
         bool first = true;
         while (!reader.EndOfStream)
         {
             string line = reader.ReadLine().Trim();
             if (line.Length > 22)
             {
                 string pointInTime = line.Substring(2, 23);
                 DateTime when = Convert.ToDateTime(pointInTime);
                 TimeSpan duration = when - previousPointInTime;
                 if (duration > maxOperationDuration)
                 {
                     trace.WriteLine(first ? fileInfo.FullName + " total: " + totalDuration.ToString() : "...");
                     trace.WriteLine(previousLine);
                     trace.WriteLine(line);
                     first = false;
                     string sourceTransition = GetOperation(previousLine);
                     string targetTransition = GetOperation(line);
                     string transition = sourceTransition + " to " + targetTransition;
                     if (transitionsCount.ContainsKey(transition))
                     {
                         TransitionInfo prev = transitionsCount[transition];
                         transitionsCount[transition] = new TransitionInfo(prev.Count + 1, prev.Duration + duration);
                     }
                     else
                     {
                         transitionsCount.Add(transition, new TransitionInfo(1, duration));
                     }
                 }
                 previousLine = line;
                 previousPointInTime = when;
             }
         }
         if (!first)
         {
             trace.WriteLine("-----------------------------------------------------------------------------------------------------------");
         }
     }
 }
        protected void GetTransitionList(ArrayList transitionList, IStateGlyph state)
        {
            // now find transitions
            foreach (IGlyph child in state.Children)
            {
                ITransitionContactPointGlyph transContactPoint = child as ITransitionContactPointGlyph;
                if (transContactPoint != null)
                {
                    ITransitionGlyph trans = transContactPoint.Owner as ITransitionGlyph;

                    if (transContactPoint.WhichEnd == TransitionContactEnd.From)
                    {
                        // this is a from transition

                        ITransitionContactPointGlyph transTo = null;
                        foreach (ITransitionContactPointGlyph contactPoint in trans.ContactPoints)
                        {
                            if (contactPoint.WhichEnd == TransitionContactEnd.To)
                            {
                                transTo = contactPoint;
                                break;
                            }
                        }
                        System.Diagnostics.Debug.Assert (transTo != null, "Transition To Contact Point not found");

                        IStateGlyph toStateGlyph = transTo.Parent as IStateGlyph;
                        string toStateName = "TRANSITION_TOSTATE_NOT_SET";
                        if (toStateGlyph != null)
                        {
                            if (IsNotEmptyString (toStateGlyph.Name))
                            {
                                toStateName = StateNameFrom (toStateGlyph);
                            }
                            else
                            {
                                toStateName = "TRANSITION_TOSTATE_SET_BUT_STATE_NOT_NAMED";
                            }
                        }

                        TransitionInfo info = new TransitionInfo (trans, StateNameFrom (state), toStateName, toStateGlyph);
                        transitionList.Add (info);
                    }
                }
            }
        }
 protected void WriteLog(StateLogType logType, IStateGlyph state, TransitionInfo transitionInfo)
 {
     WriteLog(logType, state, transitionInfo, "s");
 }
        /// <summary>
        /// Запуск анимации ячейки. Пройдёт время и анимация закончится, не стоит об этом беспокоиться.
        /// Всё работу берёт на себя AnimationManager.
        /// </summary>
        /// <param name="cell">Шашечка, которая поедет в дальний край. Шашка официально должна находится на финальной позиции.</param>
        /// <param name="startPosition">Позиция, с которой начинается движение.</param>
        public void StartTransition(
            CellPlate cell,
            Rectangle startPosition)
        {
            TransitionInfo transition = transitionByCell[cell] as TransitionInfo;

            if (transition != null)
            {
                transition.InvalidateTransitionArea();
                transitionByCell.Remove(cell);
            }

            transition = new TransitionInfo(
                cell,
                startPosition);

            transitionByCell[cell] = transition;

            UpdateTimer();
        }
示例#35
0
        /// <summary>
        /// Modifies the attributes for a property in the schema.
        /// </summary>
        /// <param name="name"> The name of the property to modify. </param>
        /// <param name="attributes"> The new attributes. </param>
        /// <returns> A new schema with the modified property. </returns>
        public HiddenClassSchema SetPropertyAttributes(string name, PropertyAttributes attributes)
        {
            // Package the name and attributes into a struct.
            var transitionInfo = new TransitionInfo() { Name = name, Attributes = attributes };

            // Check if there is a transition to the schema already.
            HiddenClassSchema newSchema = null;
            if (this.modifyTransitions != null)
                this.modifyTransitions.TryGetValue(transitionInfo, out newSchema);

            if (newSchema == null)
            {
                // Create the properties dictionary if it hasn't already been created.
                if (this.properties == null)
                    this.properties = CreatePropertiesDictionary();

                // Check the attributes differ from the existing attributes.
                SchemaProperty propertyInfo;
                if (this.properties.TryGetValue(name, out propertyInfo) == false)
                    throw new InvalidOperationException(string.Format("The property '{0}' does not exist.", name));
                if (attributes == propertyInfo.Attributes)
                    return this;

                // Create a new schema based on this one.
                var properties = new Dictionary<string, SchemaProperty>(this.properties);
                properties[name] = new SchemaProperty(propertyInfo.Index, attributes);
                newSchema = new HiddenClassSchema(properties, this.NextValueIndex);

                // Add a transition to the new schema.
                if (this.modifyTransitions == null)
                    this.modifyTransitions = new Dictionary<TransitionInfo, HiddenClassSchema>(1);
                this.modifyTransitions.Add(transitionInfo, newSchema);
            }

            return newSchema;
        }
示例#36
0
 /// <summary>
 /// Creates a new HiddenClassSchema instance from an add operation.
 /// </summary>
 private HiddenClassSchema(Dictionary<string, SchemaProperty> properties, int nextValueIndex, HiddenClassSchema parent, TransitionInfo addPropertyTransitionInfo)
     : this(properties, nextValueIndex)
 {
     this.parent = parent;
     this.addPropertyTransitionInfo = addPropertyTransitionInfo;
 }
 protected void WriteLog(StateLogType logType, IStateGlyph state, TransitionInfo transitionInfo, string transitionFieldNamePrefix)
 {
     if (CanInstrument (state))
     {
         string text = NormalisedTransitionDisplayText (transitionInfo);
         WriteLine ("LogStateEvent (StateLogType.{0}, s_{1}, {5}_{2}, \"{3}\", \"{4}\");", logType, StateNameFrom (state), transitionInfo.ToStateName, transitionInfo.Transition.QualifiedEvent, text, transitionFieldNamePrefix);
     }
 }
示例#38
0
        /// <summary>
        /// Adds a property to the schema.
        /// </summary>
        /// <param name="name"> The name of the property to add. </param>
        /// <param name="attributes"> The property attributes. </param>
        /// <returns> A new schema with the extra property. </returns>
        public HiddenClassSchema AddProperty(string name, PropertyAttributes attributes = PropertyAttributes.FullAccess)
        {
            // Package the name and attributes into a struct.
            var transitionInfo = new TransitionInfo() { Name = name, Attributes = attributes };

            // Check if there is a transition to the schema already.
            HiddenClassSchema newSchema = null;
            if (this.addTransitions != null)
                this.addTransitions.TryGetValue(transitionInfo, out newSchema);

            if (newSchema == null)
            {
                if (this.parent == null)
                {
                    // Create a new schema based on this one.  A complete copy must be made of the properties hashtable.
                    var properties = new Dictionary<string, SchemaProperty>(this.properties);
                    properties.Add(name, new SchemaProperty(this.NextValueIndex, attributes));
                    newSchema = new HiddenClassSchema(properties, this.NextValueIndex + 1, this, transitionInfo);
                }
                else
                {
                    // Create a new schema based on this one.  The properties hashtable is "given
                    // away" so a copy does not have to be made.
                    if (this.properties == null)
                        this.properties = CreatePropertiesDictionary();
                    this.properties.Add(name, new SchemaProperty(this.NextValueIndex, attributes));
                    newSchema = new HiddenClassSchema(this.properties, this.NextValueIndex + 1, this, transitionInfo);
                    this.properties = null;
                }
                

                // Add a transition to the new schema.
                if (this.addTransitions == null)
                    this.addTransitions = new Dictionary<TransitionInfo, HiddenClassSchema>(1);
                this.addTransitions.Add(transitionInfo, newSchema);
            }

            return newSchema;
        }
示例#39
0
 private bool MustResample(TransitionInfo info)
 {
     return (this.mustResample || !info.IsEqual(this.m_RefTransitionInfo));
 }
 protected string NormalisedTransitionDisplayText(TransitionInfo transitionInfo)
 {
     return NormalisedTransitionDisplayText (transitionInfo.Transition);
 }
示例#41
0
 private void ResampleTransition(AnimatorStateTransition transition, AvatarMask layerMask, TransitionInfo info, Animator previewObject)
 {
     this.m_IsResampling = true;
     this.m_MustResample = false;
     bool flag = this.m_RefTransition != transition;
     this.m_RefTransition = transition;
     this.m_RefTransitionInfo = info;
     this.m_LayerMask = layerMask;
     if (this.m_AvatarPreview != null)
     {
         this.m_AvatarPreview.OnDestroy();
         this.m_AvatarPreview = null;
     }
     this.ClearController();
     Motion motion = this.m_RefSrcState.motion;
     this.Init(previewObject, (motion == null) ? this.m_RefDstState.motion : motion);
     if (this.m_Controller != null)
     {
         this.m_AvatarPreview.Animator.allowConstantClipSamplingOptimization = false;
         this.m_StateMachine.defaultState = this.m_DstState;
         this.m_Transition.mute = true;
         AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
         this.m_AvatarPreview.Animator.Update(1E-05f);
         this.WriteParametersInController();
         this.m_AvatarPreview.Animator.SetLayerWeight(this.m_LayerIndex, 1f);
         float length = this.m_AvatarPreview.Animator.GetCurrentAnimatorStateInfo(this.m_LayerIndex).length;
         this.m_StateMachine.defaultState = this.m_SrcState;
         this.m_Transition.mute = false;
         AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
         this.m_AvatarPreview.Animator.Update(1E-05f);
         this.WriteParametersInController();
         this.m_AvatarPreview.Animator.SetLayerWeight(this.m_LayerIndex, 1f);
         float num2 = this.m_AvatarPreview.Animator.GetCurrentAnimatorStateInfo(this.m_LayerIndex).length;
         if (this.m_LayerIndex > 0)
         {
             this.m_AvatarPreview.Animator.stabilizeFeet = false;
         }
         float num3 = ((num2 * this.m_RefTransition.exitTime) + (this.m_Transition.duration * (!this.m_RefTransition.hasFixedDuration ? num2 : 1f))) + length;
         if (num3 > 2000f)
         {
             Debug.LogWarning("Transition duration is longer than 2000 second, Disabling previewer.");
             this.m_ValidTransition = false;
         }
         else
         {
             float num4 = (this.m_RefTransition.exitTime <= 0f) ? num2 : (num2 * this.m_RefTransition.exitTime);
             float a = (num4 <= 0f) ? 0.03333334f : Mathf.Min(Mathf.Max((float) (num4 / 300f), (float) 0.03333334f), num4 / 5f);
             float num6 = (length <= 0f) ? 0.03333334f : Mathf.Min(Mathf.Max((float) (length / 300f), (float) 0.03333334f), length / 5f);
             a = Mathf.Max(a, num3 / 300f);
             num6 = Mathf.Max(num6, num3 / 300f);
             float deltaTime = a;
             float num8 = 0f;
             bool flag2 = false;
             bool flag3 = false;
             bool flag4 = false;
             this.m_AvatarPreview.Animator.StartRecording(-1);
             this.m_LeftStateWeightA = 0f;
             this.m_LeftStateTimeA = 0f;
             this.m_AvatarPreview.Animator.Update(0f);
             int num9 = 0;
             while (!flag4)
             {
                 num9++;
                 this.m_AvatarPreview.Animator.Update(deltaTime);
                 AnimatorStateInfo currentAnimatorStateInfo = this.m_AvatarPreview.Animator.GetCurrentAnimatorStateInfo(this.m_LayerIndex);
                 num8 += deltaTime;
                 if (!flag2)
                 {
                     this.m_LeftStateWeightA = currentAnimatorStateInfo.normalizedTime;
                     this.m_LeftStateTimeA = num8;
                     flag2 = true;
                 }
                 if (flag3 && (num8 >= num3))
                 {
                     flag4 = true;
                 }
                 if (!flag3 && currentAnimatorStateInfo.IsName(this.m_DstState.name))
                 {
                     this.m_RightStateWeightA = currentAnimatorStateInfo.normalizedTime;
                     this.m_RightStateTimeA = num8;
                     flag3 = true;
                 }
                 if (!flag3)
                 {
                     this.m_LeftStateWeightB = currentAnimatorStateInfo.normalizedTime;
                     this.m_LeftStateTimeB = num8;
                 }
                 if (flag3)
                 {
                     this.m_RightStateWeightB = currentAnimatorStateInfo.normalizedTime;
                     this.m_RightStateTimeB = num8;
                 }
                 if (this.m_AvatarPreview.Animator.IsInTransition(this.m_LayerIndex))
                 {
                     deltaTime = num6;
                 }
             }
             float num10 = num8;
             this.m_AvatarPreview.Animator.StopRecording();
             if (Mathf.Approximately(this.m_LeftStateWeightB, this.m_LeftStateWeightA) || Mathf.Approximately(this.m_RightStateWeightB, this.m_RightStateWeightA))
             {
                 Debug.LogWarning("Speed difference between states is too big. Transition preview will be disabled.");
                 this.m_ValidTransition = false;
             }
             else
             {
                 float num11 = (this.m_LeftStateTimeB - this.m_LeftStateTimeA) / (this.m_LeftStateWeightB - this.m_LeftStateWeightA);
                 float num12 = (this.m_RightStateTimeB - this.m_RightStateTimeA) / (this.m_RightStateWeightB - this.m_RightStateWeightA);
                 if (this.m_MustSampleMotions)
                 {
                     this.m_MustSampleMotions = false;
                     this.m_SrcPivotList.Clear();
                     this.m_DstPivotList.Clear();
                     deltaTime = num6;
                     this.m_StateMachine.defaultState = this.m_DstState;
                     this.m_Transition.mute = true;
                     AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
                     this.m_AvatarPreview.Animator.Update(0f);
                     this.m_AvatarPreview.Animator.SetLayerWeight(this.m_LayerIndex, 1f);
                     this.m_AvatarPreview.Animator.Update(1E-07f);
                     this.WriteParametersInController();
                     for (num8 = 0f; num8 <= num12; num8 += deltaTime * 2f)
                     {
                         Timeline.PivotSample item = new Timeline.PivotSample {
                             m_Time = num8,
                             m_Weight = this.m_AvatarPreview.Animator.pivotWeight
                         };
                         this.m_DstPivotList.Add(item);
                         this.m_AvatarPreview.Animator.Update(deltaTime * 2f);
                     }
                     deltaTime = a;
                     this.m_StateMachine.defaultState = this.m_SrcState;
                     this.m_Transition.mute = true;
                     AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
                     this.m_AvatarPreview.Animator.Update(1E-07f);
                     this.WriteParametersInController();
                     this.m_AvatarPreview.Animator.SetLayerWeight(this.m_LayerIndex, 1f);
                     for (num8 = 0f; num8 <= num11; num8 += deltaTime * 2f)
                     {
                         Timeline.PivotSample sample2 = new Timeline.PivotSample {
                             m_Time = num8,
                             m_Weight = this.m_AvatarPreview.Animator.pivotWeight
                         };
                         this.m_SrcPivotList.Add(sample2);
                         this.m_AvatarPreview.Animator.Update(deltaTime * 2f);
                     }
                     this.m_Transition.mute = false;
                     AnimatorController.SetAnimatorController(this.m_AvatarPreview.Animator, this.m_Controller);
                     this.m_AvatarPreview.Animator.Update(1E-07f);
                     this.WriteParametersInController();
                 }
                 this.m_Timeline.StopTime = this.m_AvatarPreview.timeControl.stopTime = num10;
                 this.m_AvatarPreview.timeControl.currentTime = this.m_Timeline.Time;
                 if (flag)
                 {
                     float num13;
                     this.m_AvatarPreview.timeControl.currentTime = num13 = this.m_AvatarPreview.timeControl.startTime = 0f;
                     this.m_Timeline.StartTime = num13;
                     this.m_Timeline.Time = num13;
                     this.m_Timeline.ResetRange();
                 }
                 this.m_AvatarPreview.Animator.StartPlayback();
                 this.m_IsResampling = false;
             }
         }
     }
 }
示例#42
0
 private void OnPreviewAvatarChanged()
 {
     this.m_RefTransitionInfo = new TransitionInfo();
     this.ClearController();
     this.CreateController();
     this.CreateParameterInfoList();
 }
示例#43
0
 public void SetTransition(AnimatorStateTransition transition, AnimatorState sourceState, AnimatorState destinationState, AnimatorControllerLayer srcLayer, Animator previewObject)
 {
     this.m_RefSrcState = sourceState;
     this.m_RefDstState = destinationState;
     TransitionInfo info = new TransitionInfo();
     info.Set(transition, sourceState, destinationState);
     if (this.MustResample(info))
     {
         this.ResampleTransition(transition, srcLayer.avatarMask, info, previewObject);
     }
 }
        protected void _addStateTransition(AnimationState fromState, 
										  AnimationState targetState, 
									      float transitionTime,
										  bool triggerOnAnimationEnd)
        {
            var newTransition = new TransitionInfo ();
            newTransition.sorce = fromState;
            newTransition.target = targetState;
            newTransition.transitionTime = transitionTime;
            newTransition.triggerOnAnimationEnd = triggerOnAnimationEnd;

            foreach (var transition in _transitions) {
                if (transition.Equals (newTransition)) {
                    var errMsg = "Idential animation transition already defined.";
                    System.Console.WriteLine (errMsg);
                    throw new Exception (errMsg);
                }
            }
            _transitions.Add (newTransition);
        }
 private static void ParseEventHandler(CompositeActivity eventHandler, List<TransitionInfo> transitions)
 {
     Queue<Activity> processingQueue = new Queue<Activity>();
     processingQueue.Enqueue(eventHandler);
     while (processingQueue.Count > 0)
     {
         Activity activity = processingQueue.Dequeue();
         SetStateActivity setState = activity as SetStateActivity;
         if (setState != null)
         {
             TransitionInfo transitionInfo = new TransitionInfo(setState, eventHandler);
             transitions.Add(transitionInfo);
         }
         else
         {
             CompositeActivity compositeActivity = activity as CompositeActivity;
             if (compositeActivity != null)
             {
                 foreach (Activity childActivity in compositeActivity.Activities)
                 {
                     processingQueue.Enqueue(childActivity);
                 }
             }
         }
     }
 }
 Transition transitionCreate(TransitionInfo data) {
     var transition = new Transition();
     transition.from = data.from;
     transition.to = data.to;
     transition.from.transitions.Add(transition);
     return transition;
 }
 internal StateDesignerConnector FindConnector(TransitionInfo transitionInfo)
 {
     foreach (Connector connector in this.Connectors)
     {
         StateDesignerConnector stateDesignerConnector = connector as StateDesignerConnector;
         if (stateDesignerConnector != null)
         {
             if (transitionInfo.Matches(stateDesignerConnector))
                 return stateDesignerConnector;
         }
     }
     return null;
 }