Esempio n. 1
0
        private void RefreshRemoteComponents(REObject remoteObject)
        {
            // CLEAR
            foreach (var component in remoteObject.Components)
            {
                _itemsDictionary.Remove(component.InstanceId);
            }

            remoteObject.Components.Clear();

            // POPULATE
            var components = remoteObject.Target.GetComponents <Component>();

            foreach (var component in components)
            {
                if (component == null)
                {
                    continue;
                }

                var componentType = component.GetType();

                var remoteComponent = new REComponent();
                remoteComponent.Target     = component;
                remoteComponent.Name       = componentType.Name;
                remoteComponent.Parent     = remoteObject;
                remoteComponent.InstanceId = component.GetInstanceID();

                remoteObject.Components.Add(remoteComponent);
                _itemsDictionary.Add(remoteComponent.InstanceId, remoteComponent);
            }
        }
        private REInvokeStatus InvokeGetObjectsCommand(Task task, List <OSCValue> inputValues, ref List <OSCValue> outputValues)
        {
            if (inputValues.Count != 4)
            {
                return(REInvokeStatus.Cancel);
            }

            if (inputValues[0].Type != OSCValueType.Int ||
                inputValues[1].Type != OSCValueType.Int ||
                inputValues[2].Type != OSCValueType.Int ||
                inputValues[3].Type != OSCValueType.String)
            {
                return(REInvokeStatus.Cancel);
            }

            var index      = inputValues[0].IntValue;
            var count      = inputValues[1].IntValue;
            var instanceId = inputValues[2].IntValue;
            var objectName = inputValues[3].StringValue;

            var remoteObject = new REObject();

            remoteObject.Name       = objectName;
            remoteObject.InstanceId = instanceId;

            if (_itemsDictionary.ContainsKey(task.ParentId) && instanceId != task.ParentId)
            {
                var parentObject = GetItem(task.ParentId) as REObject;
                if (parentObject != null)
                {
                    remoteObject.Parent = parentObject;
                    parentObject.Childs.Add(remoteObject);
                }
            }

            if (_itemsDictionary.ContainsKey(remoteObject.InstanceId))
            {
                _itemsDictionary.Remove(remoteObject.InstanceId);
            }

            _itemsDictionary.Add(remoteObject.InstanceId, remoteObject);

            task.Process(instanceId);

            index++;

            if (index >= count)
            {
                return(REInvokeStatus.Cancel);
            }

            outputValues.Add(OSCValue.Int(index));

            return(REInvokeStatus.Complete);
        }
Esempio n. 3
0
        private REObject CreateObject(GameObject obj)
        {
            var remoteObject = new REObject();

            remoteObject.InstanceId = obj.GetInstanceID();
            remoteObject.Target     = obj;
            remoteObject.Name       = obj.name;

            RefreshRemoteComponents(remoteObject);

            return(remoteObject);
        }
Esempio n. 4
0
        private void RefreshRemoteChildObjects(REObject remoteObject)
        {
            // CLEAR
            foreach (var child in remoteObject.Childs)
            {
                _itemsDictionary.Remove(child.InstanceId);
            }

            remoteObject.Childs.Clear();

            // POPULATE
            var rootTransform = remoteObject.Target.transform;

            foreach (Transform childTransform in rootTransform)
            {
                var childObject = CreateObject(childTransform.gameObject);
                childObject.Parent = remoteObject;

                remoteObject.Childs.Add(childObject);
                _itemsDictionary.Add(childObject.InstanceId, childObject);
            }
        }