private static void CreateUniqueName(this ShaderGroup group)
 {
     if (!group.HasUniqueName)
     {
         group.UniqueName = CreateUniqueName(group.Name, MainWindowPageViewModel.ShaderBoxResourcesFolderLocation, "");
     }
 }
        //private void SaveAs(ShaderGroup group, string name)
        //{

        //}

        private void RaiseSaveShaderGroup(ShaderGroup group)
        {
            foreach (Shader shader in group.Shaders)
            {
                shader.Save(Workspace);
            }
        }
示例#3
0
        void AddGroup(GroupData groupData)
        {
            ShaderGroup graphGroup = new ShaderGroup();

            graphGroup.userData = groupData;
            graphGroup.title    = groupData.title;

            m_GraphView.AddElement(graphGroup);
        }
 private void RaiseCloseShaderGroup(ShaderGroup group)
 {
     SetValue(group, false, () =>
     {
         group.Save(Workspace);
         Workspace.Shaders.FirstOrDefault((s) => s.Path == group.GetProjectPath()).IsOpen = group.IsOpen;
         ShaderGroupsView.Refresh();
     }, "IsOpen");
 }
        void AddGroup(GroupData groupData)
        {
            ShaderGroup graphGroup = new ShaderGroup(m_Graph);

            graphGroup.userData = groupData;
            graphGroup.title    = groupData.title;
            graphGroup.SetPosition(new Rect(graphGroup.userData.position, Vector2.zero));

            m_GraphView.AddElement(graphGroup);
        }
 private void RefreshExplorerEvent(ShaderGroup shaderGroup)
 {
     if (shaderGroup != null)
     {
         foreach (Shader shader in shaderGroup.Shaders)
         {
             ShadersFlattened.Remove(shader);
         }
     }
     ShaderGroupsView.Refresh();
 }
        private void RaiseEditShaderGroup(ShaderGroup group)
        {
            ShaderGroupNotification notification = new ShaderGroupNotification();

            notification.ShaderGroup = group.Copy();
            notification.Title       = "Edit Shader";
            notification.Content     = true;

            bool          selectionNeedsUpdate = false;
            int           selectedIndex        = ShaderGroupsView.CurrentPosition;
            List <Shader> openItems            = ShaderGroupsView.Cast <Shader>().ToList();
            int           originalCount        = group.Shaders.Count;
            int           startIndex           = 0;

            if (openItems[selectedIndex].Group == group)
            {
                selectionNeedsUpdate = true;
                startIndex           = openItems.IndexOf(group.Shaders[0]);
            }

            ShaderGroupRequest.Raise(notification, (returned) =>
            {
                if (returned.Confirmed)
                {
                    int flattenedIndex = ShadersFlattened.IndexOf(group.Shaders[0]);

                    int index = _shaderStorage.ShaderGroups.IndexOf(group);
                    _shaderStorage.ShaderGroups.Remove(group);
                    _shaderStorage.ShaderGroups.Insert(index, notification.ShaderGroup);

                    group.AnnotationShaderGroups.Clear();
                    group.IsBuilded = false;

                    group.Shaders.ToList().ForEach((s) => ShadersFlattened.Remove(s));
                    for (int i = 0; i < notification.ShaderGroup.Shaders.Count; ++i)
                    {
                        ShadersFlattened.Insert(flattenedIndex + i, notification.ShaderGroup.Shaders[i]);
                    }

                    if (selectionNeedsUpdate)
                    {
                        selectedIndex = Math.Min(openItems.Count - 1, selectedIndex);
                        if (startIndex + notification.ShaderGroup.Shaders.Count <= selectedIndex)
                        {
                            selectedIndex = startIndex + notification.ShaderGroup.Shaders.Count - 1;
                        }
                        ShaderGroupsView.MoveCurrentToPosition(selectedIndex);
                    }
                }
            });
        }
        public static string GetProjectPath(this ShaderGroup shadergroup)
        {
            string path;

            if (shadergroup.ShaderGroupType == ShaderGroupType.SharedHeaders)
            {
                path = MainWindowPageViewModel.ShaderBoxSharedProject;
            }
            else
            {
                path = $"{MainWindowPageViewModel.ShaderBoxResourcesFolderLocation}{shadergroup.UniqueName}/{shadergroup.Name}.sbproj";
            }
            return(path);
        }
        private void UpdateShaderViewport()
        {
            if (ViewportHost != null)
            {
                if (SelectedShaderGroup != null && SelectedShaderGroup.IsBuilded)
                {
                    string[] shaderLocations = new string[5];
                    foreach (Shader s in SelectedShaderGroup.Shaders)
                    {
                        if (s.ShaderType != ShaderType.Header)
                        {
                            shaderLocations[(int)s.ShaderType] = $"{MainWindowPageViewModel.ShaderBoxResourcesFolderLocation}{SelectedShaderGroup.UniqueName}/.cso/{s.GetShaderTarget().Substring(0, 2)}.cso";
                        }
                    }
                    bool isStandard = SelectedShaderGroup.ShaderGroupType == ShaderGroupType.Standard;
                    if (isStandard)
                    {
                        ViewportHost.SetShaders(shaderLocations[0] ?? "", shaderLocations[1] ?? "", shaderLocations[2] ?? "", shaderLocations[3] ?? "", shaderLocations[4] ?? "");
                        ViewportHost.SetTopology((int)SelectedShaderGroup.Topology);
                        ViewportHost.SetRasterizerState((int)SelectedShaderGroup.CullMode, (int)SelectedShaderGroup.FillMode);
                    }
                    else
                    {
                        ViewportHost.SetPPShader(shaderLocations[4] ?? "");
                    }
                    _settedGroup = SelectedShaderGroup;

                    foreach (AnnotationShaderGroup annotationShaderGroup in SelectedShaderGroup.AnnotationShaderGroups)
                    {
                        foreach (AnnotationGroup annotationGroup in annotationShaderGroup.Buffers)
                        {
                            foreach (AnnotationVariable annotationVariable in annotationGroup.AnnotationVariables)
                            {
                                annotationVariable.UpdateBuffer(false);
                            }
                            annotationGroup.MarshalBuffer(ViewportHost, isStandard);
                        }
                    }
                }

                ViewportHost.SetModel(SelectedModel?.Path ?? Workspace.Models[0].Path);
                ViewportHost.SetCameraOffset(CameraOffset);

                RaisePropertyChanged("SelectedModel");
            }
        }
        public static ShaderGroup Copy(this ShaderGroup group)
        {
            return(new ShaderGroup()
            {
                Name = group.Name,
                ShaderGroupType = group.ShaderGroupType,
                Topology = group.Topology,
                Description = group.Description,
                UniqueName = group.UniqueName,
                IsOpen = group.IsOpen,
                HasHullDomainShader = group.HasHullDomainShader,
                HasGeometryShader = group.HasGeometryShader,
                CullMode = group.CullMode,
                FillMode = group.FillMode,

                Shaders = new ObservableCollection <Shader>(group.Shaders)
            });
        }
        private void RaiseAddHeader(ShaderGroup group)
        {
            string name = "Header";
            IEnumerable <string> headers = group.Shaders.Where((s) => s.ShaderType == ShaderType.Header).Select((s) => s.Name);

            int counter = 0;

            while (headers.Contains(name + ".hlsli"))
            {
                ++counter;
                name = "Header_" + counter.ToString("D3");
            }

            Shader shader = new Shader(name + ".hlsli", ShaderType.Header);

            group.AddShader(shader);
            group.Save(Workspace);

            ShadersFlattened.Add(shader);
        }
        private void RaiseMakeSharedHeader(Shader shader)
        {
            ShaderGroup originalGroup = shader.Group;

            shader.Group.Shaders.Remove(shader);

            string name    = shader.Name.TrimEnd(".hlsli".ToArray());
            string newName = shader.Name;

            IEnumerable <string> headers = _shaderStorage.ShaderGroups[0].Shaders.Select((s) => s.Name);
            int counter = 0;

            while (headers.Contains(newName))
            {
                ++counter;
                newName = name + "_" + counter.ToString("D3") + ".hlsli";
            }

            shader.Name = newName;

            if (!string.IsNullOrEmpty(shader.FileLocation))
            {
                try
                {
                    File.Copy(shader.FileLocation, PATH_TO_SHARED_FOLDER + name);
                    File.Delete(shader.FileLocation);
                    shader.FileLocation = PATH_TO_SHARED_FOLDER + name;
                }
                catch (Exception) { }
            }

            _shaderStorage.ShaderGroups[0].AddShader(shader);

            originalGroup.Save(Workspace);
            _shaderStorage.ShaderGroups[0].Save(Workspace);

            ShaderGroupsView.Refresh();
        }
        public static void Save(this ShaderGroup shadergroup, Workspace workspace)
        {
            shadergroup.CreateUniqueName();

            string path = shadergroup.GetProjectPath();

            if (workspace.Shaders.FirstOrDefault((s) => s.Path == path) == null)
            {
                workspace.Shaders.Add(new ShaderPath()
                {
                    Path   = path,
                    IsOpen = true
                });
            }
            path.EnsureFolder();

            XmlSerializer serializer = new XmlSerializer(typeof(ShaderGroup));

            using (Stream stream = File.Create(path))
            {
                serializer.Serialize(stream, shadergroup);
            }
        }
示例#14
0
 public ShaderGroupWrapper_GTA5_pc(ShaderGroup shaderGroup)
 {
     this.shaderGroup = shaderGroup;
 }
示例#15
0
        public new void Read(BinaryReader br)
        {
            base.Read(br);

            // rage::rmcDrawableBase
            //    rage::rmcDrawable
            //        gtaDrawable

            var shaderGroupOffset = ResourceUtil.ReadOffset(br);
            var skeletonOffset    = ResourceUtil.ReadOffset(br);

            Center    = new Vector4(br);
            BoundsMin = new Vector4(br);
            BoundsMax = new Vector4(br);

            int levelOfDetailCount = 0;
            var modelOffsets       = new uint[4];

            for (int i = 0; i < 4; i++)
            {
                modelOffsets[i] = ResourceUtil.ReadOffset(br);
                if (modelOffsets[i] != 0)
                {
                    levelOfDetailCount++;
                }
            }

            AbsoluteMax = new Vector4(br);

            Unk1 = br.ReadUInt32();

            Neg1 = br.ReadUInt32();
            Neg2 = br.ReadUInt32();
            Neg3 = br.ReadUInt32();

            Unk2 = br.ReadSingle();

            Unk3 = br.ReadUInt32();
            Unk4 = br.ReadUInt32();
            Unk5 = br.ReadUInt32();

            // Collection<LightAttrs>
            Unk6 = br.ReadUInt32();
            Unk7 = br.ReadUInt32();

            // The data follows:

            if (shaderGroupOffset != 0)
            {
                br.BaseStream.Seek(shaderGroupOffset, SeekOrigin.Begin);
                ShaderGroup = new ShaderGroup(br);
            }

            if (skeletonOffset != 0)
            {
                br.BaseStream.Seek(skeletonOffset, SeekOrigin.Begin);
                Skeleton = new Skeleton(br);
            }

            ModelCollection = new PtrCollection <Model> [levelOfDetailCount];
            for (int i = 0; i < levelOfDetailCount; i++)
            {
                br.BaseStream.Seek(modelOffsets[i], SeekOrigin.Begin);
                ModelCollection[i] = new PtrCollection <Model>(br);
            }
        }
示例#16
0
    //finds all properties and headers and stores them in correct order
    private void CollectAllProperties()
    {
        //load display names from file if it exists
        MaterialProperty[]          props  = current.properties;
        Dictionary <string, string> labels = LoadDisplayNamesFromFile();

        LoadLocales();

        current.propertyDictionary = new Dictionary <string, ShaderProperty>();
        shaderparts = new ShaderHeader();                            //init top object that all Shader Objects are childs of
        Stack <ShaderGroup> headerStack = new Stack <ShaderGroup>(); //header stack. used to keep track if current header to parent new objects to

        headerStack.Push(shaderparts);                               //add top object as top object to stack
        headerStack.Push(shaderparts);                               //add top object a second time, because it get's popped with first actual header item
        footer = new List <ButtonData>();                            //init footer list
        int headerCount = 0;

        Type         materialPropertyDrawerType = typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.MaterialPropertyHandler");
        MethodInfo   getPropertyHandlerMethod   = materialPropertyDrawerType.GetMethod("GetShaderPropertyHandler", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
        PropertyInfo drawerProperty             = materialPropertyDrawerType.GetProperty("propertyDrawer");

        Type      materialToggleDrawerType = typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.MaterialToggleDrawer");
        FieldInfo keyWordField             = materialToggleDrawerType.GetField("keyword", BindingFlags.Instance | BindingFlags.NonPublic);

        for (int i = 0; i < props.Length; i++)
        {
            string displayName = props[i].displayName;
            if (locale != null)
            {
                foreach (string key in locale.GetAllKeys())
                {
                    if (displayName.Contains("locale::" + key))
                    {
                        displayName = displayName.Replace("locale::" + key, locale.Get(key));
                    }
                }
            }
            displayName = Regex.Replace(displayName, @"''", "\"");

            if (labels.ContainsKey(props[i].name))
            {
                displayName = labels[props[i].name];
            }
            PropertyOptions options = ExtractExtraOptionsFromDisplayName(ref displayName);

            int offset = options.offset + headerCount;

            //Handle keywords
            object propertyHandler = getPropertyHandlerMethod.Invoke(null, new object[] { current.shader, props[i].name });
            //if has custom drawer
            if (propertyHandler != null)
            {
                object propertyDrawer = drawerProperty.GetValue(propertyHandler, null);
                //if custom drawer exists
                if (propertyDrawer != null)
                {
                    if (propertyDrawer.GetType().ToString() == "UnityEditor.MaterialToggleDrawer")
                    {
                        object keyword = keyWordField.GetValue(propertyDrawer);
                        if (keyword != null)
                        {
                            foreach (Material m in current.materials)
                            {
                                if (m.GetFloat(props[i].name) == 1)
                                {
                                    m.EnableKeyword((string)keyword);
                                }
                                else
                                {
                                    m.DisableKeyword((string)keyword);
                                }
                            }
                        }
                    }
                }
            }


            ThryPropertyType type = GetPropertyType(props[i], options);
            switch (type)
            {
            case ThryPropertyType.header:
                headerStack.Pop();
                break;

            case ThryPropertyType.header_start:
                offset = options.offset + ++headerCount;
                break;

            case ThryPropertyType.header_end:
                headerStack.Pop();
                headerCount--;
                break;

            case ThryPropertyType.on_swap_to:
                on_swap_to_actions = options.actions;
                break;
            }
            ShaderProperty newPorperty = null;
            switch (type)
            {
            case ThryPropertyType.master_label:
                masterLabelText = displayName;
                break;

            case ThryPropertyType.footer:
                footer.Add(Parser.ParseToObject <ButtonData>(displayName));
                break;

            case ThryPropertyType.header:
            case ThryPropertyType.header_start:
                ShaderHeader newHeader = new ShaderHeader(props[i], current.editor, displayName, offset, options);
                headerStack.Peek().addPart(newHeader);
                headerStack.Push(newHeader);
                break;

            case ThryPropertyType.group_start:
                ShaderGroup new_group = new ShaderGroup(options);
                headerStack.Peek().addPart(new_group);
                headerStack.Push(new_group);
                break;

            case ThryPropertyType.group_end:
                headerStack.Pop();
                break;

            case ThryPropertyType.none:
            case ThryPropertyType.property:
                DrawingData.lastPropertyUsedCustomDrawer = false;
                current.editor.GetPropertyHeight(props[i]);
                bool forceOneLine = props[i].type == MaterialProperty.PropType.Vector && !DrawingData.lastPropertyUsedCustomDrawer;
                if (props[i].type == MaterialProperty.PropType.Texture)
                {
                    newPorperty = new TextureProperty(props[i], displayName, offset, options, props[i].flags != MaterialProperty.PropFlags.NoScaleOffset, !DrawingData.lastPropertyUsedCustomDrawer);
                }
                else
                {
                    newPorperty = new ShaderProperty(props[i], displayName, offset, options, forceOneLine);
                }
                break;

            case ThryPropertyType.lightmap_flags:
                newPorperty = new GIProperty(props[i], displayName, offset, options, false);
                break;

            case ThryPropertyType.dsgi:
                newPorperty = new DSGIProperty(props[i], displayName, offset, options, false);
                break;

            case ThryPropertyType.instancing:
                newPorperty = new InstancingProperty(props[i], displayName, offset, options, false);
                break;

            case ThryPropertyType.locale:
                newPorperty = new LocaleProperty(props[i], displayName, offset, options, false);
                break;
            }
            if (newPorperty != null)
            {
                if (current.propertyDictionary.ContainsKey(props[i].name))
                {
                    continue;
                }
                current.propertyDictionary.Add(props[i].name, newPorperty);
                if (type != ThryPropertyType.none)
                {
                    headerStack.Peek().addPart(newPorperty);
                }
            }
        }
    }
        public MainWindowPageViewModel()
        {
            Workspace workspace = null;

            try
            {
                if (File.Exists(ShaderBoxRootFileLocation))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(Workspace));
                    using (Stream stream = File.OpenRead(ShaderBoxRootFileLocation))
                    {
                        workspace = ((Workspace)serializer.Deserialize(stream));
                    }
                }
            }
            catch (Exception)
            {
            }
            finally
            {
                if (workspace == null)
                {
                    workspace = new Workspace();
                }
                if (workspace.Shaders.Count == 0 || workspace.Shaders.FirstOrDefault((s) => s.Path == ShaderBoxSharedProject) == null)
                {
                    workspace.Shaders.Insert(0, new ShaderPath()
                    {
                        Path   = ShaderBoxSharedProject,
                        IsOpen = true
                    });
                }

                if (workspace.Models.Count == 0 || workspace.Models.FirstOrDefault((s) => s.Path == ShaderBoxBuiltInModel) == null)
                {
                    workspace.Models.Insert(0, new Model3DData()
                    {
                        Hash      = 0,
                        ImagePath = ShaderBoxBuiltInModelImage,
                        IsBuiltIn = true,
                        Name      = "Cube.obj",
                        Path      = ShaderBoxBuiltInModel
                    });
                }

                if (!File.Exists(ShaderBoxSharedProject))
                {
                    ShaderGroup group = new ShaderGroup("Shared headers [../.Shared/]", ShaderGroupType.SharedHeaders)
                    {
                        UniqueName = ShaderBoxSharedFolderName,
                        IsOpen     = true
                    };

                    Shader shader = new Shader("SB_Header.hlsli", ShaderType.Header, ShaderBoxBaseShaderLocation);
                    shader.IsBuiltIn = true;
                    group.AddShader(shader);
                    group.Save(workspace);
                }

                ShaderStorageLinker shaderStorage = new ShaderStorageLinker();
                XmlSerializer       serializer    = new XmlSerializer(typeof(ShaderGroup));
                List <ShaderPath>   toDelete      = new List <ShaderPath>();
                foreach (ShaderPath sPath in workspace.Shaders)
                {
                    try
                    {
                        using (Stream stream = File.OpenRead(sPath.Path))
                        {
                            ShaderGroup group = (ShaderGroup)serializer.Deserialize(stream);
                            group.IsOpen = sPath.IsOpen;
                            shaderStorage.ShaderGroups.Add(group);
                        }
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show($"Failed to load project: {sPath.Path}\nError: {e}", "Load error", MessageBoxButton.OK, MessageBoxImage.Error);
                        toDelete.Add(sPath);
                    }
                }
                workspace.Shaders = workspace.Shaders.Except(toDelete).ToList();

                if (!File.Exists(ShaderBoxBaseShaderLocation))
                {
                    ShaderBoxSharedFolderLocation.EnsureFolder();
                    using (StreamWriter stream = new StreamWriter(ShaderBoxBaseShaderLocation))
                    {
                        stream.Write(ShaderBoxBaseShaderContent);
                    }
                }

                _workspace = workspace;
                _workspace.PropertyChanged += new PropertyChangedEventHandler(OnResourcePropertyChanged);
                App.Container.RegisterInstance(workspace);
                App.Container.RegisterInstance(shaderStorage);

                // Resolve cyclic dependency
                foreach (ShaderGroup shaderGroup in shaderStorage.ShaderGroups)
                {
                    foreach (Shader shader in shaderGroup.Shaders)
                    {
                        shader.Group = shaderGroup;
                    }
                    foreach (AnnotationShaderGroup annotationShaderGroup in shaderGroup.AnnotationShaderGroups)
                    {
                        annotationShaderGroup.CreateUI();
                    }
                }
            }
        }
示例#18
0
        void SetGroupPosition(ShaderGroup groupNode)
        {
            var pos = groupNode.GetPosition();

            groupNode.userData.position = new Vector2(pos.x, pos.y);
        }
示例#19
0
    //finds all properties and headers and stores them in correct order
    private void CollectAllProperties()
    {
        //load display names from file if it exists
        MaterialProperty[]          props  = current.properties;
        Dictionary <string, string> labels = LoadDisplayNamesFromFile();

        LoadLocales();

        current.propertyDictionary = new Dictionary <string, ShaderProperty>();
        shaderparts = new ShaderHeader();                            //init top object that all Shader Objects are childs of
        Stack <ShaderGroup> headerStack = new Stack <ShaderGroup>(); //header stack. used to keep track if current header to parent new objects to

        headerStack.Push(shaderparts);                               //add top object as top object to stack
        headerStack.Push(shaderparts);                               //add top object a second time, because it get's popped with first actual header item
        footer = new List <ButtonData>();                            //init footer list
        int headerCount = 0;

        for (int i = 0; i < props.Length; i++)
        {
            string displayName = props[i].displayName;
            if (locale != null)
            {
                foreach (string key in locale.GetAllKeys())
                {
                    displayName = displayName.Replace("locale::" + key, locale.Get(key));
                }
            }
            displayName = Regex.Replace(displayName, @"''", "\"");

            if (labels.ContainsKey(props[i].name))
            {
                displayName = labels[props[i].name];
            }
            PropertyOptions options = ExtractExtraOptionsFromDisplayName(ref displayName);

            int offset = options.offset + headerCount;

            ThryPropertyType type = GetPropertyType(props[i]);
            switch (type)
            {
            case ThryPropertyType.header:
                headerStack.Pop();
                break;

            case ThryPropertyType.header_start:
                offset = options.offset + ++headerCount;
                break;

            case ThryPropertyType.header_end:
                headerStack.Pop();
                headerCount--;
                break;
            }
            ShaderProperty newPorperty = null;
            switch (type)
            {
            case ThryPropertyType.master_label:
                masterLabelText = displayName;
                break;

            case ThryPropertyType.footer:
                footer.Add(Parser.ParseToObject <ButtonData>(displayName));
                break;

            case ThryPropertyType.header:
            case ThryPropertyType.header_start:
                ShaderHeader newHeader = new ShaderHeader(props[i], current.editor, displayName, offset, options);
                headerStack.Peek().addPart(newHeader);
                headerStack.Push(newHeader);
                break;

            case ThryPropertyType.group_start:
                ShaderGroup new_group = new ShaderGroup(options);
                headerStack.Peek().addPart(new_group);
                headerStack.Push(new_group);
                break;

            case ThryPropertyType.group_end:
                headerStack.Pop();
                break;

            case ThryPropertyType.none:
            case ThryPropertyType.property:
                DrawingData.lastPropertyUsedCustomDrawer = false;
                current.editor.GetPropertyHeight(props[i]);
                bool forceOneLine = props[i].type == MaterialProperty.PropType.Vector && !DrawingData.lastPropertyUsedCustomDrawer;
                if (props[i].type == MaterialProperty.PropType.Texture)
                {
                    newPorperty = new TextureProperty(props[i], displayName, offset, options, props[i].flags != MaterialProperty.PropFlags.NoScaleOffset, !DrawingData.lastPropertyUsedCustomDrawer);
                }
                else
                {
                    newPorperty = new ShaderProperty(props[i], displayName, offset, options, forceOneLine);
                }
                break;

            case ThryPropertyType.lightmap_flags:
                newPorperty = new GIProperty(props[i], displayName, offset, options, false);
                break;

            case ThryPropertyType.dsgi:
                newPorperty = new DSGIProperty(props[i], displayName, offset, options, false);
                break;

            case ThryPropertyType.instancing:
                newPorperty = new InstancingProperty(props[i], displayName, offset, options, false);
                break;

            case ThryPropertyType.locale:
                newPorperty = new LocaleProperty(props[i], displayName, offset, options, false);
                break;
            }
            if (newPorperty != null)
            {
                current.propertyDictionary.Add(props[i].name, newPorperty);
                if (type != ThryPropertyType.none)
                {
                    headerStack.Peek().addPart(newPorperty);
                }
            }
        }
    }
示例#20
0
        private Drawable TryConvertDrawable(FbxDocument fdoc, string name)
        {
            var rootnodes = fdoc.GetSceneNodes();

            var mlists   = new List <List <FbxModel> >();
            var mlistall = new List <FbxModel>();

            foreach (var node in rootnodes)
            {
                if (node.Name == "Model")
                {
                    var mlist = TryConvertModels(node); //flatten any models structure with depth >2
                    if (mlist != null)
                    {
                        mlists.Add(mlist);
                        mlistall.AddRange(mlist);
                    }
                }
            }

            var mlHigh = new List <DrawableModel>();
            var mlMed  = new List <DrawableModel>();
            var mlLow  = new List <DrawableModel>();
            var mlVlow = new List <DrawableModel>();
            var mlUnks = new List <DrawableModel>();
            var mlAll  = new List <DrawableModel>();

            foreach (var m in mlistall)
            {
                var mnl = m.Name.ToLowerInvariant();
                if (mnl.EndsWith("_vlow"))
                {
                    mlVlow.Add(m.Model);
                }
                else if (mnl.EndsWith("_low"))
                {
                    mlLow.Add(m.Model);
                }
                else if (mnl.EndsWith("_med"))
                {
                    mlMed.Add(m.Model);
                }
                else if (mnl.EndsWith("_high"))
                {
                    mlHigh.Add(m.Model);
                }
                else
                {
                    mlUnks.Add(m.Model);
                }
            }
            if (mlHigh.Count == 0)//mlUnks could be embedded collisions... ignore for now
            {
                mlHigh.AddRange(mlUnks);
            }
            mlAll.AddRange(mlHigh);
            mlAll.AddRange(mlMed);
            mlAll.AddRange(mlLow);
            mlAll.AddRange(mlVlow);



            var allVerts = new List <Vector3>();
            var bbMin    = new Vector3(float.MaxValue);
            var bbMax    = new Vector3(float.MinValue);
            var bsCen    = Vector3.Zero;
            var bsRad    = 0.0f;

            foreach (var m in mlistall)
            {
                if (m?.Model?.Geometries == null)
                {
                    continue;
                }
                foreach (var g in m.Model.Geometries)
                {
                    var vb = g.VertexData.VertexBytes;
                    var vs = g.VertexData.VertexStride;
                    var vc = g.VertexData.VertexCount;
                    for (int i = 0; i < vc; i++)
                    {
                        var vp = MetaTypes.ConvertData <Vector3>(vb, i * vs);//position offset should always be 0!
                        allVerts.Add(vp);
                        bbMin = Vector3.Min(bbMin, vp);
                        bbMax = Vector3.Max(bbMax, vp);
                        //bsCen += vp;
                    }
                }
            }
            if (allVerts.Count > 0)
            {
                //bsCen = bsCen / allVerts.Count;
                bsCen = (bbMin + bbMax) * 0.5f;
                foreach (var vp in allVerts)
                {
                    bsRad = Math.Max(bsRad, (vp - bsCen).Length());
                }
            }



            var sgrp  = new ShaderGroup();
            var slist = new List <ShaderFX>();
            var smapp = new List <ushort>();

            foreach (var m in mlAll)
            {
                if (m?.Geometries == null)
                {
                    continue;
                }
                smapp.Clear();
                foreach (var g in m.Geometries)
                {
                    smapp.Add((ushort)slist.Count);
                    slist.Add(g.Shader);
                }
                m.ShaderMapping = smapp.ToArray();//TODO: re-use shaders!!
            }
            sgrp.Shaders            = new ResourcePointerArray64 <ShaderFX>();
            sgrp.Shaders.data_items = slist.ToArray();
            sgrp.ShadersCount1      = (ushort)slist.Count;
            sgrp.ShadersCount2      = (ushort)slist.Count;
            sgrp.VFT         = 1080113376;                  //is this needed?
            sgrp.Unknown_4h  = 1;
            sgrp.Unknown_30h = (uint)(8 + slist.Count * 3); //WTF is this?


            var d = new Drawable();

            d.Name                 = name + ".#dr";
            d.ShaderGroup          = sgrp;
            d.BoundingCenter       = bsCen;
            d.BoundingSphereRadius = bsRad;
            d.BoundingBoxMin       = bbMin;
            d.BoundingBoxMax       = bbMax;
            d.LodDistHigh          = 9998;//lod dist defaults
            d.LodDistMed           = 9998;
            d.LodDistLow           = 9998;
            d.LodDistVlow          = 9998;
            d.Unknown_9Ah          = 33;//WTF is this???
            d.FileVFT              = 1079446584;
            d.FileUnknown          = 1;
            d.DrawableModels       = new DrawableModelsBlock();
            if (mlHigh.Count > 0)
            {
                d.DrawableModels.High = mlHigh.ToArray();
                d.FlagsHigh           = 1;//what flags should be used??
            }
            if (mlMed.Count > 0)
            {
                d.DrawableModels.Med = mlMed.ToArray();
                d.LodDistHigh        = bsRad * 2.0f; //when med models present, generate a high lod dist..
                d.FlagsMed           = 1;
            }
            if (mlLow.Count > 0)
            {
                d.DrawableModels.Low = mlLow.ToArray();
                d.LodDistMed         = bsRad * 8.0f; //when low models present, generate a med lod dist..
                d.FlagsLow           = 1;
            }
            if (mlVlow.Count > 0)
            {
                d.DrawableModels.VLow = mlVlow.ToArray();
                d.LodDistLow          = bsRad * 32.0f; //when vlow models present, generate a low lod dist..
                d.FlagsVlow           = 1;
            }

            d.BuildRenderMasks();

            d.LightAttributes = new ResourceSimpleList64_s <LightAttributes_s>();
            //todo: light attributes?


            return(d);
        }
        private void RaiseNewShader()
        {
            if (IsValid)
            {
                if (_isInEditMode)
                {
                    if ((_originalHasHullDomain && HasHullDomainShader == false) ||// Hull and domain will get deleted
                        (_originalHasGeometry && HasGeometryShader == false))   // Geometry will get deleted
                    {
                        MessageBoxResult result = MessageBox.Show("The new settings will result in permanently losing shaders\n\nDo you want to continue", "Warning", MessageBoxButton.YesNo, MessageBoxImage.Warning);
                        if (result != MessageBoxResult.Yes)
                        {
                            return;
                        }
                    }
                }
                ShaderGroup sg = _notification.ShaderGroup;
                Shader      shader;
                if (sg.ShaderGroupType == ShaderGroupType.Standard)
                {
                    if (HasHullDomainShader)
                    {
                        shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Hull);
                        if (shader == null)
                        {
                            sg.AddShader(new Shader("hs.hlsl", ShaderType.Hull));
                            sg.AddShader(new Shader("ds.hlsl", ShaderType.Domain));
                        }
                    }
                    else if (_isInEditMode)
                    {
                        shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Hull);
                        shader?.Delete();
                        sg.Shaders.Remove(shader);

                        shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Domain);
                        shader?.Delete();
                        sg.Shaders.Remove(shader);
                    }

                    if (HasGeometryShader)
                    {
                        shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Geometry);
                        if (shader == null)
                        {
                            sg.AddShader(new Shader("gs.hlsl", ShaderType.Geometry));
                        }
                    }
                    else if (_isInEditMode)
                    {
                        shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Geometry);
                        shader?.Delete();
                        sg.Shaders.Remove(shader);
                    }

                    shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Vertex);
                    if (shader == null)
                    {
                        sg.AddShader(new Shader("vs.hlsl", ShaderType.Vertex));
                    }
                }
                else if (_isInEditMode)
                {
                    shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Vertex);
                    shader?.Delete();
                    sg.Shaders.Remove(shader);
                    shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Hull);
                    shader?.Delete();
                    sg.Shaders.Remove(shader);
                    shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Domain);
                    shader?.Delete();
                    sg.Shaders.Remove(shader);
                    shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Geometry);
                    shader?.Delete();
                    sg.Shaders.Remove(shader);
                }

                shader = sg.Shaders.FirstOrDefault((s) => s.ShaderType == ShaderType.Pixel);
                if (shader == null)
                {
                    sg.AddShader(new Shader("ps.hlsl", ShaderType.Pixel));
                }

                if (_isInEditMode)
                {
                    foreach (Shader s in sg.Shaders)
                    {
                        s.Group = sg;
                    }
                }
                _notification.Confirmed = true;
                FinishInteraction();
            }
        }