Exemplo n.º 1
0
        public MocapPipeline(bool loadFromEditorPrefs)
        {
            loadProfiles(loadFromEditorPrefs);

            // Load Filters
            filters = MocapFilter.loadAvailableFilters();

            preMapFilters.Clear();
            postMapFilters.Clear();
            foreach (MocapFilter filter in filters)
            {
                if (filter.PreMapping)
                {
                    preMapFilters.Add(filter);
                }
                else
                {
                    postMapFilters.Add(filter);
                }
            }

            LoadEditorPrefs();

            //Sort lists
            preMapFilters.Sort((x, y) => x.Ordinal.CompareTo(y.Ordinal));
            postMapFilters.Sort((x, y) => x.Ordinal.CompareTo(y.Ordinal));

            spoolUpInputEvents();
        }
Exemplo n.º 2
0
        /// <summary>
        /// Create instances of all Mocap Filters in the assembly and return the collection.
        /// </summary>
        /// <returns>The collection of filters</returns>
        public static List <MocapFilter> loadAvailableFilters()
        {
            List <MocapFilter> filters = new List <MocapFilter>();

            List <Type> types = CinemaMocapHelper.GetFilters();

            foreach (Type t in types)
            {
                MocapFilter filter = Activator.CreateInstance(t) as MocapFilter;
                if (filter != null)
                {
                    filters.Add(filter);

                    foreach (NameAttribute attribute in t.GetCustomAttributes(typeof(NameAttribute), true))
                    {
                        filter.Name = attribute.Name;
                    }

                    foreach (MocapFilterAttribute attribute in t.GetCustomAttributes(typeof(MocapFilterAttribute), true))
                    {
                        filter.PreMapping = attribute.PreMapping;
                    }
                    foreach (OrdinalAttribute attribute in t.GetCustomAttributes(typeof(OrdinalAttribute), true))
                    {
                        filter.Ordinal = attribute.Ordinal;
                    }
                }
            }

            return(filters);
        }
Exemplo n.º 3
0
        public void DrawMappingSettings()
        {
            bool hasMappingSettingBeenAltered = false;

            // Draw Mapping Settings
            if (MappingProfile != null)
            {
                if (MappingProfile.UpdateParameters())
                {
                    hasMappingSettingBeenAltered = true;
                }
            }

            int swapIndex = -1;
            int swapDir   = 0; //1 = up, 2 = down

            // Draw Pre-Mapping filters
            for (int i = 0; i < preMapFilters.Count; i++)
            {
                MocapFilter filter = preMapFilters[i];

                EditorGUILayout.BeginHorizontal();

                bool temp = EditorGUILayout.Toggle(new GUIContent(filter.Name), filter.Enabled);
                if (temp != filter.Enabled)
                {
                    filter.Enabled = temp;
                    hasMappingSettingBeenAltered = true;
                }

                EditorGUI.BeginDisabledGroup(i == 0);
                if (GUILayout.Button("\u25B2 ", EditorStyles.miniButton, GUILayout.Width(moveBtnWidth)))
                {
                    swapIndex = i;
                    swapDir   = 1;
                }
                EditorGUI.EndDisabledGroup();

                EditorGUI.BeginDisabledGroup(i == (preMapFilters.Count - 1));
                if (GUILayout.Button("\u25BC ", EditorStyles.miniButton, GUILayout.Width(moveBtnWidth)))
                {
                    swapIndex = i;
                    swapDir   = 2;
                }
                EditorGUI.EndDisabledGroup();

                EditorGUILayout.EndHorizontal();
                if (filter.Enabled)
                {
                    if (filter.UpdateParameters())
                    {
                        hasMappingSettingBeenAltered = true;
                    }
                }
            }

            //Apply any swaps to preMapFilters
            if (swapIndex != -1)
            {
                if (swapDir == 1) // Move up
                {
                    MocapFilter temp = preMapFilters[swapIndex - 1];
                    preMapFilters[swapIndex - 1] = preMapFilters[swapIndex];
                    preMapFilters[swapIndex]     = temp;
                }
                else if (swapDir == 2) // Move down
                {
                    MocapFilter temp = preMapFilters[swapIndex + 1];
                    preMapFilters[swapIndex + 1] = preMapFilters[swapIndex];
                    preMapFilters[swapIndex]     = temp;
                }
            }



            swapIndex = -1;
            swapDir   = 0; //1 = up, 2 = down
                           // Draw Post-Mapping filters
            for (int i = 0; i < postMapFilters.Count; i++)
            {
                MocapFilter filter = postMapFilters[i];

                EditorGUILayout.BeginHorizontal();

                var temp = EditorGUILayout.Toggle(new GUIContent(filter.Name), filter.Enabled);
                if (temp != filter.Enabled)
                {
                    filter.Enabled = temp;
                    hasMappingSettingBeenAltered = true;
                }

                EditorGUI.BeginDisabledGroup(i == 0);
                if (GUILayout.Button("\u25B2", EditorStyles.miniButton, GUILayout.Width(moveBtnWidth)))
                {
                    swapIndex = i;
                    swapDir   = 1;
                }
                EditorGUI.EndDisabledGroup();

                EditorGUI.BeginDisabledGroup(i == (postMapFilters.Count - 1));
                if (GUILayout.Button("\u25BC", EditorStyles.miniButton, GUILayout.Width(moveBtnWidth)))
                {
                    swapIndex = i;
                    swapDir   = 2;
                }
                EditorGUI.EndDisabledGroup();

                EditorGUILayout.EndHorizontal();
                if (filter.Enabled)
                {
                    if (filter.UpdateParameters())
                    {
                        hasMappingSettingBeenAltered = true;
                    }
                }
            }

            //Apply any swaps to postSwapFilters
            if (swapIndex != -1)
            {
                if (swapDir == 1) // Move up
                {
                    MocapFilter temp = postMapFilters[swapIndex - 1];
                    postMapFilters[swapIndex - 1] = postMapFilters[swapIndex];
                    postMapFilters[swapIndex]     = temp;
                }
                else if (swapDir == 2) // Move down
                {
                    MocapFilter temp = postMapFilters[swapIndex + 1];
                    postMapFilters[swapIndex + 1] = postMapFilters[swapIndex];
                    postMapFilters[swapIndex]     = temp;
                }
            }


            if (hasMappingSettingBeenAltered && MappingSettingsUpdated != null)
            {
                MappingSettingsUpdated(this, new BaseSystem.EventArgs());
            }
        }