zoukankan      html  css  js  c++  java
  • unity3d各种OpenFileDialog操作

     

    (此内容为转载)

    unity3d各种OpenFileDialog操作

     
    1 编辑模式(Editor)下:
     string path = EditorUtility.OpenFilePanel("Load png Textures of Directory", "", "");
     WWW ww=new WWW("file:///"+path);
      print(ww.url);
      yield return ww;
      gui.texture=ww.texture;

    2.非编辑模式:
          OpenFileDialog ofd = new OpenFileDialog();                //new一个方法
          ofd.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);   //      定义打开的默认文件夹位置
            if(ofd.ShowDialog()==DialogResult.OK)
            {
              //显示打开文件的窗口
             Debug.Log( ofd.FileName);
            }
    以上操作需要添加 System.Windows.Forms.dll,放在Plugins文件夹下,同时需要更改.net 2.0 Subset为.net2.0  但是不知道什么原因,会频繁的崩溃。

    3 非编辑模式
    一下红色部分作者所写,其余都是摘抄http://unifycommunity.com/wiki/
    using UnityEngine;
    using System.Collections;

    public class TextFileFinder : MonoBehaviour {
        public static bool flag;
        public GUITexture text;
        protected string m_textPath;
        public GUISkin skin;
        protected FileBrowser m_fileBrowser;
        [SerializeField]
        protected Texture2D m_directoryImage,
                            m_fileImage;
        protected void OnGUI () {
            GUI.skin=skin;
            if (m_fileBrowser != null) {
                m_fileBrowser.OnGUI();
            } else {
               OnGUIMain();
            }
        }
        void Update()
        {
            if(flag)
            {
                StartCoroutine(WaitLoad());
                flag=false;
            }
        }
        IEnumerator WaitLoad()
        {
            WWW aa=new WWW("file:///"+m_textPath);
            print(aa.url);
            yield return aa;
            text.texture=aa.texture;
        }
        protected void OnGUIMain() {
            GUILayout.BeginHorizontal();
                GUILayout.Label("Text File", GUILayout.Width(100));
                GUILayout.FlexibleSpace();
                GUILayout.Label(m_textPath ?? "none selected");
                if (GUILayout.Button("...", GUILayout.ExpandWidth(false))) {

                    m_fileBrowser = new FileBrowser(
                       new Rect(100, 100, 600, 500),
                        "Choose Text File",
                        FileSelectedCallback
                    );
                    m_fileBrowser.SelectionPattern = "*.png";
                    m_fileBrowser.DirectoryImage = m_directoryImage;
                    m_fileBrowser.FileImage = m_fileImage;
                }
            GUILayout.EndHorizontal();
        }
        protected void FileSelectedCallback(string path) {
            m_fileBrowser = null;
            m_textPath = path;
        }
    }

     FileBrowser 摘抄

    using UnityEngine;

    using System;

    using System.IO;

    using System.Collections.Generic;

    public enum FileBrowserType {

        File,

        Directory

    }
    public class FileBrowser {
        // Called when the user clicks cancel or select

        public delegate void FinishedCallback(string path);

        // Defaults to working directory

        public string CurrentDirectory {
            get {
                return m_currentDirectory;
            }
            set {
                SetNewDirectory(value);
                SwitchDirectoryNow();
            }
        }

        protected string m_currentDirectory;

        // Optional pattern for filtering selectable files/folders. See:

        // http://msdn.microsoft.com/en-us/library/wz42302f(v=VS.90).aspx

        // and

        // http://msdn.microsoft.com/en-us/library/6ff71z1w(v=VS.90).aspx

        public string SelectionPattern {
            get {
                return m_filePattern;
            }
            set {
                m_filePattern = value;
                ReadDirectoryContents();
            }
        }
        protected string m_filePattern;
        // Optional image for directories
        public Texture2D DirectoryImage {
            get {
                return m_directoryImage;
            }
            set {
                m_directoryImage = value;
                BuildContent();
            }
        }
        protected Texture2D m_directoryImage;
        // Optional image for files

        public Texture2D FileImage {
            get {
                return m_fileImage;
            }
            set {
                m_fileImage = value;
                BuildContent();
            }
        }

        protected Texture2D m_fileImage;
        // Browser type. Defaults to File, but can be set to Folder
        public FileBrowserType BrowserType {
            get {
                return m_browserType;
            }
            set {
                m_browserType = value;
                ReadDirectoryContents();
            }
        }
        protected FileBrowserType m_browserType;

        protected string m_newDirectory;

        protected string[] m_currentDirectoryParts;
        protected string[] m_files;
        protected GUIContent[] m_filesWithImages;

        protected int m_selectedFile;
        protected string[] m_nonMatchingFiles;
        protected GUIContent[] m_nonMatchingFilesWithImages;
        protected int m_selectedNonMatchingDirectory;
        protected string[] m_directories;

        protected GUIContent[] m_directoriesWithImages;

        protected int m_selectedDirectory;
        protected string[] m_nonMatchingDirectories;

        protected GUIContent[] m_nonMatchingDirectoriesWithImages;
        protected bool m_currentDirectoryMatches;
        protected GUIStyle CentredText {
            get {
                if (m_centredText == null) {
                    m_centredText = new GUIStyle(GUI.skin.label);
                    m_centredText.alignment = TextAnchor.MiddleLeft;
                    m_centredText.fixedHeight = GUI.skin.button.fixedHeight;
                }
                return m_centredText;
            }
        }
        protected GUIStyle m_centredText;
        protected string m_name;
        protected Rect m_screenRect;

        protected Vector2 m_scrollPosition;

        protected FinishedCallback m_callback;

       

        // Browsers need at least a rect, name and callback

        public FileBrowser(Rect screenRect, string name, FinishedCallback callback) {

            m_name = name;

            m_screenRect = screenRect;

            m_browserType = FileBrowserType.File;

            m_callback = callback;

            SetNewDirectory(Directory.GetCurrentDirectory());

            SwitchDirectoryNow();

        }

       

        protected void SetNewDirectory(string directory) {

            m_newDirectory = directory;

        }

       

        protected void SwitchDirectoryNow() {

            if (m_newDirectory == null || m_currentDirectory == m_newDirectory) {

                return;

            }

            m_currentDirectory = m_newDirectory;

            m_scrollPosition = Vector2.zero;

            m_selectedDirectory = m_selectedNonMatchingDirectory = m_selectedFile = -1;

            ReadDirectoryContents();

        }

       

        protected void ReadDirectoryContents() {

            if (m_currentDirectory == "/") {

                m_currentDirectoryParts = new string[] {""};

                m_currentDirectoryMatches = false;

            } else {

                m_currentDirectoryParts = m_currentDirectory.Split(Path.DirectorySeparatorChar);

                if (SelectionPattern != null) {

    //                string[] generation = Directory.GetDirectories(

    //                    Path.GetDirectoryName(m_currentDirectory),

    //                    SelectionPattern

    //                );

    //                m_currentDirectoryMatches = Array.IndexOf(generation, m_currentDirectory) >= 0;

                   

                     string directoryName = Path.GetDirectoryName(m_currentDirectory);

            string[] generation = new string[0];

            if(directoryName != null)

            {   //This is new: generation should be an empty array for the root directory.

                //directoryName will be null if it's a root directory

                generation = Directory.GetDirectories(

                directoryName,

                SelectionPattern );

            }

            m_currentDirectoryMatches = Array.IndexOf(generation, m_currentDirectory) >= 0;



                   

                } else {

                    m_currentDirectoryMatches = false;

                }

            }

           

            if (BrowserType == FileBrowserType.File || SelectionPattern == null) {

                m_directories = Directory.GetDirectories(m_currentDirectory);

                m_nonMatchingDirectories = new string[0];

            } else {

                m_directories = Directory.GetDirectories(m_currentDirectory, SelectionPattern);

                var nonMatchingDirectories = new List<string>();

                foreach (string directoryPath in Directory.GetDirectories(m_currentDirectory)) {

                    if (Array.IndexOf(m_directories, directoryPath) < 0) {

                        nonMatchingDirectories.Add(directoryPath);

                    }

                }

                m_nonMatchingDirectories = nonMatchingDirectories.ToArray();

                for (int i = 0; i < m_nonMatchingDirectories.Length; ++i) {

                    int lastSeparator = m_nonMatchingDirectories[i].LastIndexOf(Path.DirectorySeparatorChar);

                    m_nonMatchingDirectories[i] = m_nonMatchingDirectories[i].Substring(lastSeparator + 1);

                }

                Array.Sort(m_nonMatchingDirectories);

            }

           

            for (int i = 0; i < m_directories.Length; ++i) {

                m_directories[i] = m_directories[i].Substring(m_directories[i].LastIndexOf(Path.DirectorySeparatorChar) + 1);

            }

           

            if (BrowserType == FileBrowserType.Directory || SelectionPattern == null) {

                m_files = Directory.GetFiles(m_currentDirectory);

                m_nonMatchingFiles = new string[0];

            } else {

                m_files = Directory.GetFiles(m_currentDirectory, SelectionPattern);

                var nonMatchingFiles = new List<string>();

                foreach (string filePath in Directory.GetFiles(m_currentDirectory)) {

                    if (Array.IndexOf(m_files, filePath) < 0) {

                        nonMatchingFiles.Add(filePath);

                    }

                }

                m_nonMatchingFiles = nonMatchingFiles.ToArray();

                for (int i = 0; i < m_nonMatchingFiles.Length; ++i) {

                    m_nonMatchingFiles[i] = Path.GetFileName(m_nonMatchingFiles[i]);

                }

                Array.Sort(m_nonMatchingFiles);

            }

            for (int i = 0; i < m_files.Length; ++i) {

                m_files[i] = Path.GetFileName(m_files[i]);

            }

            Array.Sort(m_files);

            BuildContent();

            m_newDirectory = null;

        }

       

        protected void BuildContent() {

            m_directoriesWithImages = new GUIContent[m_directories.Length];

            for (int i = 0; i < m_directoriesWithImages.Length; ++i) {

                m_directoriesWithImages[i] = new GUIContent(m_directories[i], DirectoryImage);

            }

            m_nonMatchingDirectoriesWithImages = new GUIContent[m_nonMatchingDirectories.Length];

            for (int i = 0; i < m_nonMatchingDirectoriesWithImages.Length; ++i) {

                m_nonMatchingDirectoriesWithImages[i] = new GUIContent(m_nonMatchingDirectories[i], DirectoryImage);

            }

            m_filesWithImages = new GUIContent[m_files.Length];

            for (int i = 0; i < m_filesWithImages.Length; ++i) {

                m_filesWithImages[i] = new GUIContent(m_files[i], FileImage);

            }

            m_nonMatchingFilesWithImages = new GUIContent[m_nonMatchingFiles.Length];

            for (int i = 0; i < m_nonMatchingFilesWithImages.Length; ++i) {

                m_nonMatchingFilesWithImages[i] = new GUIContent(m_nonMatchingFiles[i], FileImage);

            }

        }
        public void OnGUI() {

            GUILayout.BeginArea(

                m_screenRect,

                m_name,

                GUI.skin.window

            );
                GUILayout.BeginHorizontal();

                    for (int parentIndex = 0; parentIndex < m_currentDirectoryParts.Length; ++parentIndex) {

                        if (parentIndex == m_currentDirectoryParts.Length - 1) {

                            GUILayout.Label(m_currentDirectoryParts[parentIndex], CentredText);

                        } else if (GUILayout.Button(m_currentDirectoryParts[parentIndex])) {

                            string parentDirectoryName = m_currentDirectory;

                            for (int i = m_currentDirectoryParts.Length - 1; i > parentIndex; --i) {

                                parentDirectoryName = Path.GetDirectoryName(parentDirectoryName);

                            }

                            SetNewDirectory(parentDirectoryName);

                        }

                    }

                    GUILayout.FlexibleSpace();

                GUILayout.EndHorizontal();

                m_scrollPosition = GUILayout.BeginScrollView(

                    m_scrollPosition,

                    false,

                    true,

                    GUI.skin.horizontalScrollbar,

                    GUI.skin.verticalScrollbar,

                    GUI.skin.box

                );

                    m_selectedDirectory = GUILayoutx.SelectionList(

                        m_selectedDirectory,

                        m_directoriesWithImages,

                        DirectoryDoubleClickCallback

                    );

                    if (m_selectedDirectory > -1) {

                        m_selectedFile = m_selectedNonMatchingDirectory = -1;

                    }

                    m_selectedNonMatchingDirectory = GUILayoutx.SelectionList(

                        m_selectedNonMatchingDirectory,

                        m_nonMatchingDirectoriesWithImages,

                        NonMatchingDirectoryDoubleClickCallback

                    );

                    if (m_selectedNonMatchingDirectory > -1) {

                        m_selectedDirectory = m_selectedFile = -1;

                    }

                    GUI.enabled = BrowserType == FileBrowserType.File;

                    m_selectedFile = GUILayoutx.SelectionList(

                        m_selectedFile,

                        m_filesWithImages,

                        FileDoubleClickCallback

                    );

                    GUI.enabled = true;

                    if (m_selectedFile > -1) {

                        m_selectedDirectory = m_selectedNonMatchingDirectory = -1;

                    }

                    GUI.enabled = false;

                    GUILayoutx.SelectionList(

                        -1,

                        m_nonMatchingFilesWithImages

                    );

                    GUI.enabled = true;

                GUILayout.EndScrollView();

                GUILayout.BeginHorizontal();

                    GUILayout.FlexibleSpace();

                    if (GUILayout.Button("Cancel", GUILayout.Width(50))) {

                        m_callback(null);

                    }

                    if (BrowserType == FileBrowserType.File) {

                        GUI.enabled = m_selectedFile > -1;

                    } else {

                        if (SelectionPattern == null) {

                            GUI.enabled = m_selectedDirectory > -1;

                        } else {

                            GUI.enabled =   m_selectedDirectory > -1 ||

                                            (

                                                m_currentDirectoryMatches &&

                                                m_selectedNonMatchingDirectory == -1 &&

                                                m_selectedFile == -1

                                            );

                        }

                    }

                    if (GUILayout.Button("Select", GUILayout.Width(50))) {

                        TextFileFinder.flag=true;

                        if (BrowserType == FileBrowserType.File) {

                            m_callback(Path.Combine(m_currentDirectory, m_files[m_selectedFile]));

                        } else {

                            if (m_selectedDirectory > -1) {

                                m_callback(Path.Combine(m_currentDirectory, m_directories[m_selectedDirectory]));

                            } else {

                                m_callback(m_currentDirectory);

                            }

                        }

                    }

                    GUI.enabled = true;

                GUILayout.EndHorizontal();

            GUILayout.EndArea();
            if (Event.current.type == EventType.Repaint) {

                SwitchDirectoryNow();

            }

        }
        protected void FileDoubleClickCallback(int i) {

            if (BrowserType == FileBrowserType.File) {

                m_callback(Path.Combine(m_currentDirectory, m_files[i]));
            }
        }
        protected void DirectoryDoubleClickCallback(int i) {

            SetNewDirectory(Path.Combine(m_currentDirectory, m_directories[i]));

        }
        protected void NonMatchingDirectoryDoubleClickCallback(int i) {

            SetNewDirectory(Path.Combine(m_currentDirectory, m_nonMatchingDirectories[i]));

        }
    }

    GUILayoutx.cs

    using UnityEngine;
    public class GUILayoutx {
        public delegate void DoubleClickCallback(int index);
        public static int SelectionList(int selected, GUIContent[] list) {
            return SelectionList(selected, list, "List Item", null);
        }
        public static int SelectionList(int selected, GUIContent[] list, GUIStyle elementStyle) {
            return SelectionList(selected, list, elementStyle, null);
        }
        public static int SelectionList(int selected, GUIContent[] list, DoubleClickCallback callback) {
            return SelectionList(selected, list, "List Item", callback);
        }
        public static int SelectionList(int selected, GUIContent[] list, GUIStyle elementStyle, DoubleClickCallback callback) {
            for (int i = 0; i < list.Length; ++i) {
                Rect elementRect = GUILayoutUtility.GetRect(list[i], elementStyle);
                bool hover = elementRect.Contains(Event.current.mousePosition);
                if (hover && Event.current.type == EventType.MouseDown&& Event.current.clickCount == 1) {
                    selected = i;
                    Event.current.Use();

                } else if (hover && callback != null && Event.current.type == EventType.MouseDown && Event.current.clickCount == 2) {
                    callback(i);
                    Event.current.Use();
                } else if (Event.current.type == EventType.repaint) {

                    elementStyle.Draw(elementRect, list[i], hover, false, i == selected, false);
                }
            }
            return selected;
        }
        public static int SelectionList(int selected, string[] list) {
            return SelectionList(selected, list, "List Item", null);
        }
        public static int SelectionList(int selected, string[] list, GUIStyle elementStyle) {
            return SelectionList(selected, list, elementStyle, null);
        }
        public static int SelectionList(int selected, string[] list, DoubleClickCallback callback) {
            return SelectionList(selected, list, "List Item", callback);
        }
        public static int SelectionList(int selected, string[] list, GUIStyle elementStyle, DoubleClickCallback callback) {
            for (int i = 0; i < list.Length; ++i) {
                Rect elementRect = GUILayoutUtility.GetRect(new GUIContent(list[i]), elementStyle);
                bool hover = elementRect.Contains(Event.current.mousePosition);
                if (hover && Event.current.type == EventType.MouseDown&& Event.current.clickCount == 1) {
                    selected = i;
                    Event.current.Use();
                } else if (hover && callback != null && Event.current.type == EventType.MouseDown && Event.current.clickCount == 2) {
                    callback(i);
                    Event.current.Use();

                } else if (Event.current.type == EventType.repaint) {

                    elementStyle.Draw(elementRect, list[i], hover, false, i == selected, false);
                }
            }
            return selected;
        }
    }
  • 相关阅读:
    -_-#【H5】meta / href
    -_-#【CSS3】CSS3 gradient transition with background-position
    ♫【jQuery】detach
    -_-#setTimeout与setInterval
    -_-#【Mac】MacVim
    -_-#【jQuery】data
    ♫【Backbone】this
    -_-#【Better JS Code】严格模式
    ♫【Node】module.filename / __filename / __dirname / process.cwd() / require.main.filename
    【图片处理】ImageMagick, gm
  • 原文地址:https://www.cnblogs.com/wzqoydn/p/6269730.html
Copyright © 2011-2022 走看看