Extract Embedded Files

Details

EyEengines.ExtractEmbededFiles.UnityEditor.dll[v0.1]

This modules provides the end user two simple classes:

• ExtractEmbededFiles: A static class with functions to extract a set of files from a dll.
• InitializeOnEditorReloadedAttribute: An attribute that can be applied to any static (action-signature) functions, so that they are executed after loading is complete, during the first Update cycle of Editor.update.

Extract embedded

The ExtractEmbededFiles class allows other DLL's to extract files from themselves, to be stored in the file system. This can be useful when a DLL requires certain files to be in place to function.

To use this class:

• You must first embed a source file to be extracted, into the DLL. This is done by in compiler, like Visual Studio.
• Then, when it's time to extract your files from the DLL, invoke the static function ExtractEmbededFiles.PromptUserToExtractFilesIfNotInPlaceAlready. This function takes a list of ExtractEmbededFiles.ExtractInfoClasses instances as a way to bundle together the strings required to extract the file, along with some import flags. These strings are the filename, the path it should be extracted to, and the namespace in the DLL where the file can be found.

This will extract the files to the application's data folder (usually the assets folder), and depending on the import options for a file, will import textures as icons or sprite for use in unity editor. Later version will include the ability to specify other kinds of import options.

example: ExtractEyeEnginesLogo.cs

using System.Collections.Generic;
using EyE.Unity;
using EyE.EditorUnity.Extraction;
using UnityEditor;
 
namespace EyE.EditorUnity.Examples
{
 
    [InitializeOnLoad]
    public class ExtractEyeEnginesLogo
    {
        static ExtractEyeEnginesLogo()
        {
            ExtractEmbededFilesInEditor.PromptUserToExtractFilesIfNotInPlaceAlready(new List<ExtractEmbededFiles.ExtractionInfo>
            {
                           
                // Constructor for a single File's ExtractionInfo
                // Use this version when you need import a texture as a sprite.
                // This version will extract the file from the DLL that is invoking this constructor.
                // Parameters:
                // "filename"-file name of the image in the dll, and the filename it will be given when extracted from the DLL and saved in the file-system. Note: the filename in the DLL is case sensitive, including the extension.</param>
                // "assetPath"-path, within the Asset Folder(do not include initial slash, nor "assets", but do include ending slash), where the file will be stored after extraction.  Folder will be created if it does not exist</param>
                // "dllNamespace"-Namespace the asset is assigned to, in the DLL.  This value is defined in the project that compiled the dll.</param>
                // "importTextureAsIcon"-boolean that specifies if the extracted file should be passed through the TextureImporter, to be configure for use as a unity editor icon.  Has no effect on assets that are not Textures. Do not pass true to both boolean parameters.</param>
                // "importTextureAsSprite"-boolean that specifies if the extracted file should be passed through the TextureImporter, to be configure for use as a unity sprite.  Has no effect on assets that are not Textures. Do not pass true to both boolean parameters.</param>
                new ExtractEmbededFiles.ExtractionInfo("EyEengines128.JPG", "Gizmos\\EyEengines\\", "EyEengines.EditorUnity.Tools",false,true),
                new ExtractEmbededFiles.ExtractionInfo("EyEenginesSprite.prefab", "Gizmos\\EyEengines\\", "EyEengines.EditorUnity.Tools",false,false),
                new ExtractEmbededFiles.ExtractionInfo("EyEengines128.JPG.meta", "Gizmos\\EyEengines\\", "EyEengines.EditorUnity.Tools",false,false),
                new ExtractEmbededFiles.ExtractionInfo("EyEenginesSprite.prefab.meta", "Gizmos\\EyEengines\\", "EyEengines.EditorUnity.Tools",false,false)
            });
        }
    }
}

InitializeOnEditorReload

To use the InitializeOnEditorReload Attribute, apply it to any static function. All attributed functions will be invoked during the first invocation of EditorApplication.Update. This attribute is similar to the [InitializeOnLoadMethodAttribute] but occurs later during initialization. It has the option, which is the default, to NOT execute when in play-mode. This behavior can be overridden, by passing true to the optional parameter of the attribute. example: InitializeOnEditorReloadExample.cs

using UnityEngine;
using UnityEditor;
using EyE.EditorUnity.Extraction;
 
namespace EyE.EditorUnity.Examples
{
 
    public class InitializeOnEditorReloadExample
    {
        // For this example, imagine that this is a third party class, out of your control that uses the InitializeOnLoadMethodAttribute, to initialize some of it's data when unity loads.
        static public class ClassThatInitializesOnLoad
        {
            public static string someData = "NotInitialized";
            [InitializeOnLoadMethod]
            public static void OnLoad()
            {
                Debug.Log("InitializeOnLoadMethod: initializing data now");
                someData = "Initialized";
            }
        }
   
        // For this example consider a class that you create, which requires that the third party class above ClassThatInitializesOnLoad complete it's initialization BEFORE your class begins it's own.
        static public class YourCustomClassThatRequiresTheThirdPartyClassIsAlreadyInitialized
        {
            [InitializeOnEditorReloaded]
            public static void AfterLoaded()
            {
                Debug.Log("InitializeOnEditorReloaded: third party data is: " + ClassThatInitializesOnLoad.someData);
                //console output will be "InitializeOnEditorReloaded: third party data is: Initialized"
            }
        }
    }
}

Modules
	EyEengines.ExtractEmbeddedFiles.UnityEditor.dll

Classes
class	EmbededXMLTooltip
	This class is sued to parse Visual Studio generated XML containing class documentation, and use this to lookup summary comments on class members, so they can be used as tool-tips at runtime. This class requires some very specific setup is done for it to function properly. It requires that an XML file containing the documentation be present, either in the asset folder, or embedded within a DLL. The name of the xml file name is either extracted from provided type's assembly name, or from a member in that type named "XMLTooltipFileNameHint" (which is accessed via reflection).
class	ExtractEmbededFiles
	Provides functions used to get images from, and extract files a .dll, into the unity Project folder. Upon invocation, the main function,RegisterFileForExtraction, will check to see if the files exist in the file system, and if not extracts then saves them to the project folder. Optionally, extracted files, may be passed through the ConvertTextureAssetToIcon function. This is done automatically when the ExtractionInfo.importTextureAsIcon for the file to extract is set to true.
class	ExtractEmbededFilesInEditor
	Provides functions used to get images from, and extract files a .dll, into the unity Project folder. Upon invocation, the main function,RegisterFileForExtraction, will check to see if the files exist in the file system, and if not extracts then saves them to the project folder. Optionally, extracted files, may be passed through the ConvertTextureAssetToIcon function. This is done automatically when the ExtractionInfo.importTextureAsIcon for the file to extract is set to true.
struct	ExtractEmbededFiles.ExtractionInfo
	Stores the source and destination information for a file that may, potentially, be extracted from a DLL into the file system.
class	InitializeOnEditorReloadedAttribute
	This attribute can be applied to static void parameterless functions. This will cause those functions to be invoked during the first cycle of EditorApplication.update. So, the editor will have finished loading.
class	InitializeOnEditorReloadedAttribute.InitializeOnEditorReloadedSetup
	This class is used internally, and not intended for end user use. Invokes OnLoad, and ensures that all methods found with the InitializeOnEditorReloadedAttribute applied will be invoked upon the first EditorApplication.Update cycle. This happens by hooking to the EditorApplication.Update during InitializeOnLoad. Then, when the delegate is invoked: executing all the methods found with this attribute, then unhooking from the delegate.