public static void CreateMyAsset()
{
NoiseBox asset = ScriptableObject.CreateInstance <NoiseBox>();
// AssetDatabase.CreateAsset(asset, "Assets/Fighter.asset");
//AssetDatabase.SaveAssets();
var path = "";
var obj = Selection.activeObject;
if (obj == null)
{
path = "Assets";
}
else
{
path = AssetDatabase.GetAssetPath(obj.GetInstanceID());
}
if (path.Length > 0 && Directory.Exists(path))
{
ProjectWindowUtil.CreateAsset(asset, path + "Noise.asset");
}
else
{
ProjectWindowUtil.CreateAsset(asset, "Assets/Noise.asset");
}
//EditorUtility.FocusProjectWindow();
//Selection.activeObject = asset;
}
public static void CreateAsset <T>() where T : ScriptableObject
{
T asset = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(asset, $"New {typeof(T).ToString()}.asset");
Selection.activeObject = asset;
}
public static T CreateAssetInSelectedDirectory <T>(string name = null) where T : ScriptableObject
{
var asset = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(asset, (string.IsNullOrEmpty(name) ? "New " + typeof(T).Name : name) + ".asset");
return(asset);
/*
* T asset = ScriptableObject.CreateInstance<T>();
*
* string path = GetAssetSelectedPath();
*
* string objName = typeof(T).ToString();
* string objExt = Path.GetExtension(objName);
* if (!string.IsNullOrEmpty(objExt))
* {
* objName = objExt.Remove(0, 1);
* }
* string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(path + (string.IsNullOrEmpty(name)? "/New " + objName : "/"+name) + ".asset");
*
* AssetDatabase.CreateAsset(asset, assetPathAndName);
* Selection.activeObject = asset;
*
* AssetDatabase.SaveAssets();
* AssetDatabase.Refresh();
* EditorUtility.FocusProjectWindow();
* return asset;*/
}
/// <summary>
/// Create asset of type T at current project window location
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="filename"></param>
/// <returns></returns>
public static T CreateAssetProjectWindow <T>(string filename) where T : ScriptableObject
{
var asset = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(asset, filename + ".asset");
return(asset);
}
public static LocalisationSettings Create()
{
current = CreateInstance <LocalisationSettings>();
ProjectWindowUtil.CreateAsset(current, "Assets/LocalisationSettings.asset");
AssetDatabase.SaveAssets();
return(current);
}
static void CreatePresetFromOpenScenes()
{
var multi = CreateInstance <MultiScene>();
multi.name = "New Multi-Scene";
var activeScene = EditorSceneManager.GetActiveScene();
var sceneCount = EditorSceneManager.sceneCount;
for (int i = 0; i < sceneCount; i++)
{
var scene = EditorSceneManager.GetSceneAt(i);
var sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scene.path);
if (activeScene == scene)
{
multi.activeScene = sceneAsset;
}
multi.sceneAssets.Add(new MultiScene.SceneInfo(sceneAsset, scene.isLoaded));
}
var directory = AssetDatabase.GetAssetPath(Selection.activeObject.GetInstanceID());
var isDirectory = Directory.Exists(directory);
if (!isDirectory)
{
directory = Path.GetDirectoryName(directory);
}
ProjectWindowUtil.CreateAsset(multi, string.Format("{0}/{1}.asset", directory, multi.name));
}
private static void CreateScriptableObject <T>(string dir) where T : ScriptableObject
{
var obj = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(obj, GetCreateScriptableObjectPath <T>(dir));
AssetDatabase.Refresh();
}
public static void CreateSwatch()
{
Swatch asset = ScriptableObject.CreateInstance <Swatch>();
ProjectWindowUtil.CreateAsset(asset, "New Swatch.asset");
AssetDatabase.SaveAssets();
}
//Helper function for creating all the ScriptableObject assets we'll need
public static ScriptableObject CreateAsset <T>(string assetName) where T : ScriptableObject
{
var asset = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(asset, assetName + " " + typeof(T).Name + ".asset");
return(asset);
}
private void RecordSelectedInformation()
{
if (m_TreeView == null || m_TreeView.selected.Count == 0)
{
return;
}
var psdLayers = m_TreeView.selected.ConvertAll(x => x.layer as IPsdLayer).ToArray();
if (exporter == null)
{
exporter = ScriptableObject.CreateInstance <Exporter>();
}
exporter.ruleObj = ruleObj;
exporter.name = "exporter" + System.DateTime.UtcNow.ToFileTimeUtc();
ProjectWindowUtil.CreateAsset(exporter, exporter.name + ".asset");
EditorUtility.SetDirty(exporter);
ExportUtility.InitPsdExportEnvrioment(exporter, new Vector2(psd.Width, psd.Height));
var rootNode = new GroupNode(new Rect(Vector2.zero, exporter.ruleObj.defultUISize), 0, -1);
rootNode.displayName = exporter.name;
var groupDatas = ExportUtility.CreatePictures(psdLayers, new Vector2(psd.Width, psd.Height), exporter.ruleObj.defultUISize, exporter.ruleObj.forceSprite);
if (groupDatas != null)
{
foreach (var groupData in groupDatas)
{
rootNode.AddChild(groupData);
ExportUtility.ChargeTextures(exporter, groupData);
}
}
TreeViewUtility.TreeToList <GroupNode>(rootNode, exporter.groups, true);
EditorUtility.SetDirty(exporter);
}
public static void CreateNewScriptObjectToProp <T>(UnityAction <T> onCreate) where T : ScriptableObject
{
var instence = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(instence, typeof(T).ToString() + ".asset");
EditorApplication.update = () =>
{
if (instence == null)
{
EditorApplication.update = null;
}
else
{
var path = AssetDatabase.GetAssetPath(instence);
if (!string.IsNullOrEmpty(path))
{
var obj = AssetDatabase.LoadAssetAtPath <T>(path);
if (onCreate != null)
{
onCreate(obj);
}
EditorApplication.update = null;
}
}
};
}
public static void Create()
{
var assetPath = "Assets/Scripts/Enemy01/ScriptableObjects/Enemy01Route.asset";
Enemy01Route asset = ScriptableObject.CreateInstance <Enemy01Route>();
ProjectWindowUtil.CreateAsset(asset, assetPath);
}
/// <summary>
/// メニューの`Assets/Create/`内の項目を選んだ時と同じ結果になるアセット生成処理。
/// </summary>
/// <remarks>
/// このメソッドでアセット生成を行った場合、
/// - アセット生成時にユーザーが選択していたフォルダ、もしくは選択していたアセットを含むフォルダ内にアセットが生成されます。
/// - また、アセット生成後に生成アセットにフォーカスが移り、リネーム処理が始まります。
/// - リネーム処理中にEscキーを押すことで生成をキャンセルする事が出来ます。
/// </remarks>
/// <param name="instance">Assetを生成するインスタンス。</param>
/// <param name="defaultAssetName">Assetの基本名。既存のアセットとパスが重複する場合は連番が振られます。</param>
public static void CreateAssetInteractivity(UnityEngine.Object instance, string defaultAssetName)
{
string targetFolder;
if (Selection.assetGUIDs.Length > 0)
{
var selectedAssetGUID = Selection.assetGUIDs.Last();
var selectedAssetPath = AssetDatabase.GUIDToAssetPath(selectedAssetGUID);
if (AssetDatabase.IsValidFolder(selectedAssetPath))
{
targetFolder = selectedAssetPath;
}
else
{
targetFolder = System.IO.Path.GetDirectoryName(selectedAssetPath);
}
}
else
{
targetFolder = "Assets";
}
var path = AssetDatabase.GenerateUniqueAssetPath(targetFolder + "/" + defaultAssetName);
ProjectWindowUtil.CreateAsset(instance, path);
}
public static T CreateGraph <T>(string directory, string fileName) where T : PWGraph
{
//generate the file path
string path = directory + "/" + fileName;
//Create the directory resource if not exists
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
//uniquify path
path = AssetDatabase.GenerateUniqueAssetPath(path);
//Create the graph, this will call OnEnable too but since the graph is not initialized this will do nothing.
T mg = ScriptableObject.CreateInstance <T>();
//Create the asset file and let the user rename it
ProjectWindowUtil.CreateAsset(mg, path);
//save and refresh Project view
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
//focus the project window
EditorUtility.FocusProjectWindow();
//focus the asset file
Selection.activeObject = mg;
return(mg);
}
static void CreateTemp()
{
var exporter = ScriptableObject.CreateInstance <Data.Exporter>();
exporter.psdFile = "";
ProjectWindowUtil.CreateAsset(exporter, "exporter.asset");
}
protected override void OnDrawProperty(SerializedProperty property)
{
if (property.propertyPath == "rule")
{
using (var hor = new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.PropertyField(rule_prop, new GUIContent("规 则"));
if (GUILayout.Button("new", EditorStyles.miniButtonRight, GUILayout.Width(40)))
{
var options = Array.ConvertAll(supportRules, x => new GUIContent(x.FullName));
var rect = new Rect(Event.current.mousePosition, Vector2.zero);
EditorUtility.DisplayCustomMenu(rect, options, -1, (x, y, id) => {
var type = supportRules[id];
var instence = ScriptableObject.CreateInstance(type);
ProjectWindowUtil.CreateAsset(instence, string.Format("new {0}.asset", type.Name));
ActionGUIUtil.DelyAcceptObject(instence, (prefab) =>
{
rule_prop = new SerializedObject(target).FindProperty("rule");
rule_prop.objectReferenceValue = prefab;
rule_prop.serializedObject.ApplyModifiedProperties();
});
}, null);
}
}
}
else
{
base.OnDrawProperty(property);
}
}
public static void Create(MenuCommand menuCommand)
{
var mesh = menuCommand.context as Mesh;
if (mesh != null)
{
var path = AssetDatabase.GetAssetPath(mesh);
if (string.IsNullOrEmpty(path) == false)
{
path = System.IO.Path.GetDirectoryName(path);
}
else
{
path = "Assets";
}
path += "/Seam Fixer (" + mesh.name + ").asset";
var instance = CreateInstance <P3dSeamFixer>();
instance.source = mesh;
ProjectWindowUtil.CreateAsset(instance, path);
}
}
private void OnWizardCreate()
{
if (audioClip.channels > 2)
{
Debug.LogError("Currently supports only 1ch or 2ch audio.");
return;
}
var data = new float[audioClip.samples * audioClip.channels];
audioClip.GetData(data, 0);
var width = Mathf.CeilToInt(Mathf.Sqrt(audioClip.samples));
var height = width;
var texture = new Texture2D(width, height, TextureFormat.RGFloat, false, true);
var colors = new Color[width * height];
if (audioClip.channels == 1)
{
for (int i = 0; i < audioClip.samples; i++)
{
colors[i] = new Color((data[i] + 1.0f) / 2.0f, (data[i] + 1.0f) / 2.0f, 0);
}
}
else
{
for (int i = 0; i < audioClip.samples; i++)
{
colors[i] = new Color((data[i * 2] + 1.0f) / 2.0f, (data[i * 2 + 1] + 1.0f) / 2.0f, 0);
}
}
texture.SetPixels(colors);
ProjectWindowUtil.CreateAsset(texture, audioClip.name + ".asset");
}
static void CreateTransformJitterAssetInstance()
{
var asset = CreateInstance <TransformJitterAsset>();
ProjectWindowUtil.CreateAsset(asset, "New TransformJitterAsset.asset");
AssetDatabase.Refresh();
}
private static void Create()
{
var name = Selection.activeObject.name;
var asset = ScriptableObject.CreateInstance(name);
ProjectWindowUtil.CreateAsset(asset, name + ".asset");
}
private static void CreatePresetFromOpenScenes()
{
MultiScene multi = CreateInstance <MultiScene>();
multi.name = "New Multi-Scene";
Scene activeScene = SceneManager.GetActiveScene();
int sceneCount = SceneManager.sceneCount;
for (int i = 0; i < sceneCount; i++)
{
Scene scene = SceneManager.GetSceneAt(i);
SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scene.path);
if (activeScene == scene)
{
multi.activeScene = sceneAsset;
}
multi.sceneAssets.Add(new MultiScene.SceneInfo(sceneAsset, scene.isLoaded));
}
string directory = AssetDatabase.GetAssetPath(Selection.activeObject.GetInstanceID());
bool isDirectory = Directory.Exists(directory);
if (!isDirectory)
{
directory = Path.GetDirectoryName(directory);
}
ProjectWindowUtil.CreateAsset(multi, $"{directory}/{multi.name}.asset");
}
void CreateMaterial()
{
var material = new Material(shader_.objectReferenceValue as Shader);
var path = string.Format("{0}/{1}.mat", GetOutputDirPath(), GetShaderName());
ProjectWindowUtil.CreateAsset(material, path);
}
static ScriptableObject InternalCreateAsset(Type type, string name, bool allowUserRename)
{
var asset = ScriptableObject.CreateInstance(type);
string path = AssetDatabase.GetAssetPath(Selection.activeObject);
if (string.IsNullOrEmpty(path))
{
path = "Assets";
}
else if (!string.IsNullOrEmpty(Path.GetExtension(path)))
{
path = path.Replace(Path.GetFileName(AssetDatabase.GetAssetPath(Selection.activeObject)), string.Empty);
}
if (string.IsNullOrEmpty(name) || name.Trim().Length < 1)
{
name = "New " + AsSpacedCamelCase(type.Name);
}
string pathName = AssetDatabase.GenerateUniqueAssetPath(string.Format("{0}/{1}.asset", path, name));
if (allowUserRename)
{
ProjectWindowUtil.CreateAsset(asset, pathName);
}
else
{
AssetDatabase.CreateAsset(asset, pathName);
}
return(asset);
}
public static RuleObject CreateRuleObject()
{
var ruleObj = ScriptableObject.CreateInstance <RuleObject>();
ProjectWindowUtil.CreateAsset(ruleObj, "new rule.asset");
return(ruleObj);
}
private void DrawElementGroup()
{
if (elementGroup_prop.objectReferenceValue == null)
{
if (GUILayout.Button("create new element group"))
{
var group = ScriptableObject.CreateInstance <ElementGroup>();
ProjectWindowUtil.CreateAsset(group, "new element_group.asset");
ActionGUIUtil.DelyAcceptObject(group, item =>
{
elementGroup_prop = new SerializedObject(target).FindProperty("elementGroup");
elementGroup_prop.objectReferenceValue = item;
elementGroup_prop.serializedObject.ApplyModifiedProperties();
});
}
}
else
{
if (elementGroupDrawer == null)
{
Editor editor = null;
Editor.CreateCachedEditor(elementGroup_prop.objectReferenceValue, typeof(ElementGroupDrawer), ref editor);
elementGroupDrawer = editor as ElementGroupDrawer;
elementGroupDrawer.showScript = false;
}
elementGroupDrawer.OnInspectorGUI();
}
}
void CreateInstanceBytype(Type instancetype)
{
var inst = CreateInstance(instancetype);
var path = CurrentSelectionFolderPath() + "/" + instancetype.Name + ".asset";
ProjectWindowUtil.CreateAsset(inst, path);
}
public override Model.NodeGraphObj CreateNodeGraphObject()
{
Model.NodeGraphObj graph = ScriptableObject.CreateInstance <T>();
graph.ControllerType = this.GetType().FullName;
ProjectWindowUtil.CreateAsset(graph, string.Format("new {0}.asset", graph.GetType().Name));
return(graph);
}
public static T CreateAndReturnAsset <T>() where T : ScriptableObject
{
var asset = ScriptableObject.CreateInstance <T>();
ProjectWindowUtil.CreateAsset(asset, "New " + typeof(T).Name + ".asset");
return(asset);
}
public static ScriptableObject CreateAsset(Type type)
{
var asset = ScriptableObject.CreateInstance(type);
ProjectWindowUtil.CreateAsset(asset, string.Format("{0}.asset", type.Name));
return(asset);
}
public static void CreateUITKTextSettingsAsset()
{
// Create new TextSettings asset
PanelTextSettings textSettings = ScriptableObject.CreateInstance <PanelTextSettings>();
ProjectWindowUtil.CreateAsset(textSettings, "UITK Text Settings.asset");
}