diff options
Diffstat (limited to 'Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Menu/AmplifyShaderEditorWindow.cs')
| -rw-r--r-- | Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Menu/AmplifyShaderEditorWindow.cs | 5945 |
1 files changed, 5945 insertions, 0 deletions
diff --git a/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Menu/AmplifyShaderEditorWindow.cs b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Menu/AmplifyShaderEditorWindow.cs new file mode 100644 index 00000000..8cbfafaf --- /dev/null +++ b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Menu/AmplifyShaderEditorWindow.cs @@ -0,0 +1,5945 @@ +// Amplify Shader Editor - Visual Shader Editing Tool +// Copyright (c) Amplify Creations, Lda <info@amplify.pt> + +using UnityEngine; +using UnityEditor; +using UnityEditor.Callbacks; +using System; +using System.Collections; +using System.Threading; +using System.Globalization; +using System.Collections.Generic; +using UnityEngine.Networking; + +namespace AmplifyShaderEditor +{ + // Disabling Substance Deprecated warning + + public class AmplifyShaderEditorWindow : SearchableEditorWindow, ISerializationCallbackReceiver + { + public const string PreviewSizeGlobalVariable = "_ASEPreviewSize"; + + public const double InactivitySaveTime = 1.0; + + public const string CopyCommand = "Copy"; + public const string PasteCommand = "Paste"; + public const string SelectAll = "SelectAll"; + public const string Duplicate = "Duplicate"; + public const string ObjectSelectorClosed = "ObjectSelectorClosed"; + public const string LiveShaderError = "Live Shader only works with an assigned Master Node on the graph"; + + //public Texture2D MasterNodeOnTexture = null; + //public Texture2D MasterNodeOffTexture = null; + + //public Texture2D GPUInstancedOnTexture = null; + //public Texture2D GPUInstancedOffTexture = null; + + private bool m_initialized = false; + private bool m_checkInvalidConnections = false; + private bool m_afterDeserializeFlag = true; + + + [SerializeField] + private ParentGraph m_customGraph = null; + + // UI + private Rect m_graphArea; + private Texture2D m_graphBgTexture; + private Texture2D m_graphFgTexture; + private GUIStyle m_graphFontStyle; + //private GUIStyle _borderStyle; + private Texture2D m_wireTexture; + + [SerializeField] + TemplatesManager m_templatesManager; + + [SerializeField] + private InnerWindowEditorVariables m_innerEditorVariables; + + [SerializeField] + private string m_lastpath; + + [SerializeField] + private ASESelectionMode m_selectionMode = ASESelectionMode.Shader; + + [SerializeField] + private DuplicatePreventionBuffer m_duplicatePreventionBuffer; + + [SerializeField] + private double m_inactivityTime = 0; + + // Prevent save ops every tick when on live mode + [SerializeField] + private double m_lastTimeSaved = 0; + + [SerializeField] + private bool m_cacheSaveOp = false; + private const double SaveTime = 1; + + private bool m_markedToSave = false; + + // Graph logic + [SerializeField] + private ParentGraph m_mainGraphInstance; + + // Camera control + [SerializeField] + private Vector2 m_cameraOffset; + + private float m_cameraSpeed = 1; + + private Rect m_cameraInfo; + + [SerializeField] + private float m_cameraZoom; + + [SerializeField] + private Vector2 m_minNodePos; + + [SerializeField] + private Vector2 m_maxNodePos; + + [SerializeField] + private bool m_isDirty; + + [SerializeField] + private bool m_saveIsDirty; + + [SerializeField] + private bool m_repaintIsDirty; + + [SerializeField] + private bool m_liveShaderEditing = false; + + [SerializeField] + private bool m_shaderIsModified = false; + + [SerializeField] + private string m_lastOpenedLocation = string.Empty; + + [SerializeField] + private bool m_zoomChanged = true; + + [SerializeField] + private float m_lastWindowWidth = 0; + + [SerializeField] + private int m_graphCount = 0; + + [SerializeField] + private double m_currentInactiveTime = 0; + + private bool m_ctrlSCallback = false; + + private bool m_altBoxSelection = false; + private bool m_altDragStarted = false; + private bool m_altPressDown = false; + private bool m_altAvailable = true; + + // Events + private Vector3 m_currentMousePos; + private Vector2 m_keyEvtMousePos2D; + private Vector2 m_currentMousePos2D; + private Event m_currentEvent; + private string m_currentCommandName = string.Empty; + private bool m_insideEditorWindow; + + private bool m_lostFocus = false; + // Selection box for multiple node selection + private bool m_multipleSelectionActive = false; + private bool m_lmbPressed = false; + private Vector2 m_multipleSelectionStart; + private Rect m_multipleSelectionArea = new Rect( 0, 0, 0, 0 ); + private bool m_autoPanDirActive = false; + private bool m_forceAutoPanDir = false; + private bool m_refreshOnUndo = false; + private bool m_loadShaderOnSelection = false; + private bool m_refreshAvailableNodes = false; + private double m_time; + + //Context Menu + private Vector2 m_rmbStartPos; + private Vector2 m_altKeyStartPos; + private GraphContextMenu m_contextMenu; + private ShortcutsManager m_shortcutManager; + + [SerializeField] + private NodeAvailability m_currentNodeAvailability = NodeAvailability.SurfaceShader; + //Clipboard + private Clipboard m_clipboard; + + //Node Parameters Window + [SerializeField] + private bool m_nodeParametersWindowMaximized = true; + private NodeParametersWindow m_nodeParametersWindow; + + // Tools Window + private ToolsWindow m_toolsWindow; + + private ConsoleLogWindow m_consoleLogWindow; + + //Editor Options + private OptionsWindow m_optionsWindow; + + // Mode Window + private ShaderEditorModeWindow m_modeWindow; + + // Tools Window + private TipsWindow m_tipsWindow; + + //Palette Window + [SerializeField] + private bool m_paletteWindowMaximized = true; + private PaletteWindow m_paletteWindow; + + private ContextPalette m_contextPalette; + private PalettePopUp m_palettePopup; + private System.Type m_paletteChosenType; + private AmplifyShaderFunction m_paletteChosenFunction; + + // In-Editor Message System + GenericMessageUI m_genericMessageUI; + private GUIContent m_genericMessageContent; + + // Drag&Drop Tool + private DragAndDropTool m_dragAndDropTool; + + //Custom Styles + //private CustomStylesContainer m_customStyles; + + private AmplifyShaderFunction m_previousShaderFunction; + + private List<MenuParent> m_registeredMenus; + + private PreMadeShaders m_preMadeShaders; + + private AutoPanData[] m_autoPanArea; + + private DrawInfo m_drawInfo; + private KeyCode m_lastKeyPressed = KeyCode.None; + private System.Type m_commentaryTypeNode; + + private int m_onLoadDone = 0; + + private float m_copyPasteDeltaMul = 0; + private Vector2 m_copyPasteInitialPos = Vector2.zero; + private Vector2 m_copyPasteDeltaPos = Vector2.zero; + + private int m_repaintCount = 0; + private bool m_forceUpdateFromMaterialFlag = false; + + private UnityEngine.Object m_delayedLoadObject = null; + private double m_focusOnSelectionTimestamp; + private double m_focusOnMasterNodeTimestamp; + private double m_wiredDoubleTapTimestamp; + + private bool m_globalPreview = false; + private bool m_globalShowInternalData = true; + + private const double AutoZoomTime = 0.25; + private const double ToggleTime = 0.25; + private const double WiredDoubleTapTime = 0.25; + private const double DoubleClickTime = 0.25; + + private Material m_delayedMaterialSet = null; + + private bool m_mouseDownOnValidArea = false; + + private bool m_removedKeyboardFocus = false; + + private int m_lastHotControl = -1; + + [SerializeField] + private bool m_isShaderFunctionWindow = false; + + private string m_currentTitle = string.Empty; + private bool m_currentTitleMod = false; + + //private Material m_maskingMaterial = null; + //private int m_cachedProjectInLinearId = -1; + private int m_cachedEditorTimeId = -1; + private int m_cachedEditorDeltaTimeId = -1; + //private float m_repaintFrequency = 15; + //private double m_repaintTimestamp = 0; + + // Smooth Zoom + private bool m_smoothZoom = false; + private float m_targetZoom; + private double m_zoomTime; + private Vector2 m_zoomPivot; + private float m_targetZoomIncrement; + private float m_zoomVelocity = 0; + + // Smooth Pan + private bool m_smoothOffset = false; + private double m_offsetTime; + private Vector2 m_targetOffset; + private Vector2 m_camVelocity = Vector2.zero; + + // Auto-Compile samples + private bool m_forcingMaterialUpdateFlag = false; + private bool m_forcingMaterialUpdateOp = false; + private List<Material> m_materialsToUpdate = new List<Material>(); + + private NodeExporterUtils m_nodeExporterUtils; + private bool m_performFullUndoRegister = true; + + [SerializeField] + private AmplifyShaderFunction m_openedShaderFunction; + + [SerializeField] + private bool m_openedAssetFromNode = false; + + private bool m_nodesLoadedCorrectly = false; + private GUIContent NodesExceptionMessage = new GUIContent( "ASE is unable to load correctly due to some faulty other classes/plugin in your project. We advise to review all your imported plugins." ); + + + private bool m_outdatedShaderFromTemplateLoaded = false; + private bool m_replaceMasterNode = false; + private AvailableShaderTypes m_replaceMasterNodeType; + private string m_replaceMasterNodeData; + private bool m_replaceMasterNodeDataFromCache; + private NodeWireReferencesUtils m_wireReferenceUtils = new NodeWireReferencesUtils(); + + private ParentNode m_nodeToFocus = null; + private float m_zoomToFocus = 1.0f; + private bool m_selectNodeToFocus = true; + + [NonSerialized] + public Dictionary<string, bool> VisitedChanged = new Dictionary<string, bool>(); + + [SerializeField] + private List<Toast> m_messages = new List<Toast>(); + + [SerializeField] + private float m_maxMsgWidth = 100; + + [SerializeField] + private bool m_maximizeMessages = false; + + [NonSerialized] + private Dictionary<string, OutputPort> m_savedList = new Dictionary<string, OutputPort>(); + + public int m_frameCounter = 0; + public double m_fpsTime = 0; + public string m_fpsDisplay = string.Empty; + +#if UNITY_EDITOR_WIN + // ScreenShot vars + IntPtr m_aseHandle; + private Rect m_prevWindowRect; + private Vector2 m_prevCameraOffset; + private float m_prevCameraZoom; + private bool m_openSavedFolder = false; + private bool m_takeScreenShot = false; +#endif + public bool CheckFunctions = false; + + // Unity Menu item + [MenuItem( "Window/Amplify Shader Editor/Open Canvas", false, 1000 )] + static void OpenMainShaderGraph() + { + if( IOUtils.AllOpenedWindows.Count > 0 ) + { + AmplifyShaderEditorWindow currentWindow = CreateTab( "Empty", UIUtils.ShaderIcon ); + UIUtils.CurrentWindow = currentWindow; + currentWindow.CreateNewGraph( "Empty" ); + currentWindow.Show(); + } + else + { + AmplifyShaderEditorWindow currentWindow = OpenWindow( "Empty", UIUtils.ShaderIcon ); + currentWindow.CreateNewGraph( "Empty" ); + //currentWindow.Show(); + } + } + + public static string GenerateTabTitle( string original, bool modified = false ) + { + GUIContent content = new GUIContent( original ); + GUIStyle tabStyle = new GUIStyle( (GUIStyle)"dragtabdropwindow" );// GUI.skin.FindStyle( "dragtabdropwindow" ); + string finalTitle = string.Empty; + bool addEllipsis = false; + for( int i = 1; i <= original.Length; i++ ) + { + content.text = original.Substring( 0, i ); + Vector2 titleSize = tabStyle.CalcSize( content ); + int maxSize = modified ? 62 : 69; + if( titleSize.x > maxSize ) + { + addEllipsis = true; + break; + } + else + { + finalTitle = content.text; + } + } + if( addEllipsis ) + finalTitle += ".."; + if( modified ) + finalTitle += "*"; + return finalTitle; + } + + public static void ConvertShaderToASE( Shader shader ) + { + if( UIUtils.IsUnityNativeShader( shader ) ) + { + Debug.LogWarningFormat( "Action not allowed. Attempting to load the native {0} shader into Amplify Shader Editor", shader.name ); + return; + } + + string guid = AssetDatabase.AssetPathToGUID( AssetDatabase.GetAssetPath( shader ) ); + if( IOUtils.AllOpenedWindows.Count > 0 ) + { + AmplifyShaderEditorWindow openedTab = null; + for( int i = 0; i < IOUtils.AllOpenedWindows.Count; i++ ) + { + //if( AssetDatabase.GetAssetPath( shader ).Equals( IOUtils.AllOpenedWindows[ i ].LastOpenedLocation ) ) + if( guid.Equals( IOUtils.AllOpenedWindows[ i ].GUID ) ) + { + openedTab = IOUtils.AllOpenedWindows[ i ]; + break; + } + } + + if( openedTab != null ) + { + openedTab.wantsMouseMove = true; + openedTab.ShowTab(); + UIUtils.CurrentWindow = openedTab; + } + else + { + EditorWindow openedWindow = AmplifyShaderEditorWindow.GetWindow<AmplifyShaderEditorWindow>(); + AmplifyShaderEditorWindow currentWindow = CreateTab(); + WindowHelper.AddTab( openedWindow, currentWindow ); + UIUtils.CurrentWindow = currentWindow; + } + } + else + { + AmplifyShaderEditorWindow currentWindow = OpenWindow( shader.name, UIUtils.ShaderIcon ); + UIUtils.CurrentWindow = currentWindow; + } + + if( IOUtils.IsASEShader( shader ) ) + { + UIUtils.CurrentWindow.LoadProjectSelected( shader ); + } + else + { + UIUtils.CreateEmptyFromInvalid( shader ); + UIUtils.ShowMessage( "Trying to open shader not created on ASE!\nBEWARE, old data will be lost if saving it here!", MessageSeverity.Warning ); + if( UIUtils.CurrentWindow.LiveShaderEditing ) + { + UIUtils.ShowMessage( "Disabling Live Shader Editing. Must manually re-enable it.", MessageSeverity.Warning ); + UIUtils.CurrentWindow.LiveShaderEditing = false; + } + } + } + + public static void LoadMaterialToASE( Material material ) + { + string guid = AssetDatabase.AssetPathToGUID( AssetDatabase.GetAssetPath( material.shader ) ); + + if( IOUtils.AllOpenedWindows.Count > 0 ) + { + AmplifyShaderEditorWindow openedTab = null; + for( int i = 0; i < IOUtils.AllOpenedWindows.Count; i++ ) + { + //if( AssetDatabase.GetAssetPath( material.shader ).Equals( IOUtils.AllOpenedWindows[ i ].LastOpenedLocation ) ) + if( guid.Equals( IOUtils.AllOpenedWindows[ i ].GUID ) ) + { + openedTab = IOUtils.AllOpenedWindows[ i ]; + break; + } + } + + if( openedTab != null ) + { + openedTab.wantsMouseMove = true; + openedTab.ShowTab(); + UIUtils.CurrentWindow = openedTab; + } + else + { + EditorWindow openedWindow = AmplifyShaderEditorWindow.GetWindow<AmplifyShaderEditorWindow>(); + AmplifyShaderEditorWindow currentWindow = CreateTab(); + WindowHelper.AddTab( openedWindow, currentWindow ); + UIUtils.CurrentWindow = currentWindow; + } + } + else + { + AmplifyShaderEditorWindow currentWindow = OpenWindow( material.name, UIUtils.MaterialIcon ); + UIUtils.CurrentWindow = currentWindow; + } + + if( IOUtils.IsASEShader( material.shader ) ) + { + UIUtils.CurrentWindow.LoadProjectSelected( material ); + } + else + { + UIUtils.CreateEmptyFromInvalid( material.shader ); + UIUtils.SetDelayedMaterialMode( material ); + } + } + + public static void LoadShaderFunctionToASE( AmplifyShaderFunction shaderFunction, bool openedAssetFromNode ) + { + string guid = AssetDatabase.AssetPathToGUID( AssetDatabase.GetAssetPath( shaderFunction ) ); + + if( IOUtils.AllOpenedWindows.Count > 0 ) + { + AmplifyShaderEditorWindow openedTab = null; + for( int i = 0; i < IOUtils.AllOpenedWindows.Count; i++ ) + { + //if( AssetDatabase.GetAssetPath( shaderFunction ).Equals( IOUtils.AllOpenedWindows[ i ].LastOpenedLocation ) ) + if( guid.Equals( IOUtils.AllOpenedWindows[ i ].GUID ) ) + { + openedTab = IOUtils.AllOpenedWindows[ i ]; + break; + } + } + + if( openedTab != null ) + { + openedTab.wantsMouseMove = true; + openedTab.ShowTab(); + UIUtils.CurrentWindow = openedTab; + } + else + { + EditorWindow openedWindow = AmplifyShaderEditorWindow.GetWindow<AmplifyShaderEditorWindow>(); + AmplifyShaderEditorWindow currentWindow = CreateTab(); + WindowHelper.AddTab( openedWindow, currentWindow ); + UIUtils.CurrentWindow = currentWindow; + } + } + else + { + AmplifyShaderEditorWindow currentWindow = OpenWindow( shaderFunction.FunctionName, UIUtils.ShaderFunctionIcon ); + UIUtils.CurrentWindow = currentWindow; + } + + UIUtils.CurrentWindow.OpenedAssetFromNode = openedAssetFromNode; + if( IOUtils.IsShaderFunction( shaderFunction.FunctionInfo ) ) + { + UIUtils.CurrentWindow.LoadProjectSelected( shaderFunction ); + } + else + { + UIUtils.CurrentWindow.titleContent.text = GenerateTabTitle( shaderFunction.FunctionName ); + UIUtils.CurrentWindow.titleContent.image = UIUtils.ShaderFunctionIcon; + UIUtils.CreateEmptyFunction( shaderFunction ); + } + } + + public static AmplifyShaderEditorWindow OpenWindow( string title = null, Texture icon = null ) + { + AmplifyShaderEditorWindow currentWindow = (AmplifyShaderEditorWindow)AmplifyShaderEditorWindow.GetWindow( typeof( AmplifyShaderEditorWindow ), false ); + currentWindow.minSize = new Vector2( ( Constants.MINIMIZE_WINDOW_LOCK_SIZE - 150 ), 270 ); + currentWindow.wantsMouseMove = true; + if( title != null ) + currentWindow.titleContent.text = GenerateTabTitle( title ); + if( icon != null ) + currentWindow.titleContent.image = icon; + return currentWindow; + } + + public static AmplifyShaderEditorWindow CreateTab( string title = null, Texture icon = null ) + { + AmplifyShaderEditorWindow currentWindow = EditorWindow.CreateInstance<AmplifyShaderEditorWindow>(); + currentWindow.minSize = new Vector2( ( Constants.MINIMIZE_WINDOW_LOCK_SIZE - 150 ), 270 ); + currentWindow.wantsMouseMove = true; + if( title != null ) + currentWindow.titleContent.text = GenerateTabTitle( title ); + if( icon != null ) + currentWindow.titleContent.image = icon; + return currentWindow; + } + + public double CalculateInactivityTime() + { + double currTime = EditorApplication.timeSinceStartup; + switch( Event.current.type ) + { + case EventType.MouseDown: + case EventType.MouseUp: + //case EventType.MouseMove: + case EventType.MouseDrag: + case EventType.KeyDown: + case EventType.KeyUp: + case EventType.ScrollWheel: + case EventType.DragUpdated: + case EventType.DragPerform: + case EventType.DragExited: + case EventType.ValidateCommand: + case EventType.ExecuteCommand: + { + m_inactivityTime = currTime; + return 0; + } + } + return currTime - m_inactivityTime; + } + + + // Shader Graph window + public override void OnEnable() + { + base.OnEnable(); + + Preferences.LoadDefaults(); + +#if UNITY_2018_3_OR_NEWER + ASEPackageManagerHelper.RequestInfo(); + ASEPackageManagerHelper.Update(); +#endif + + Shader.SetGlobalVector( PreviewSizeGlobalVariable, new Vector4( ParentNode.PreviewWidth, ParentNode.PreviewHeight, 0, 0 ) ); + + if( m_templatesManager == null ) + { + m_templatesManager = IOUtils.FirstValidTemplatesManager; + if( m_templatesManager == null ) + { + m_templatesManager = ScriptableObject.CreateInstance<TemplatesManager>(); + m_templatesManager.Init(); + if( TemplatesManager.ShowDebugMessages ) + Debug.Log( "Creating Manager" ); + } + else + { + if( TemplatesManager.ShowDebugMessages ) + Debug.Log( "Assigning Manager" ); + } + } + else if( !m_templatesManager.Initialized ) + { + if( TemplatesManager.ShowDebugMessages ) + Debug.Log( "Re-Initializing Manager" ); + m_templatesManager.Init(); + } + TemplatePostProcessor.Destroy(); + if( m_innerEditorVariables == null ) + { + m_innerEditorVariables = new InnerWindowEditorVariables(); + m_innerEditorVariables.Initialize(); + } + + if( m_mainGraphInstance == null ) + { + m_mainGraphInstance = CreateInstance<ParentGraph>(); + m_mainGraphInstance.Init(); + m_mainGraphInstance.ParentWindow = this; + m_mainGraphInstance.SetGraphId( 0 ); + } + m_mainGraphInstance.ResetEvents(); + m_mainGraphInstance.OnNodeEvent += OnNodeStoppedMovingEvent; + m_mainGraphInstance.OnMaterialUpdatedEvent += OnMaterialUpdated; + m_mainGraphInstance.OnShaderUpdatedEvent += OnShaderUpdated; + m_mainGraphInstance.OnEmptyGraphDetectedEvt += OnEmptyGraphDetected; + m_mainGraphInstance.OnNodeRemovedEvent += m_toolsWindow.OnNodeRemovedFromGraph; + GraphCount = 1; + + IOUtils.Init(); + IOUtils.AllOpenedWindows.Add( this ); + + // Only runs once for multiple windows + EditorApplication.update -= IOUtils.UpdateIO; + EditorApplication.update += IOUtils.UpdateIO; + + //EditorApplication.update -= UpdateTime; + EditorApplication.update -= UpdateNodePreviewListAndTime; + //EditorApplication.update += UpdateTime; + + EditorApplication.update += UpdateNodePreviewListAndTime; + + + if( CurrentSelection == ASESelectionMode.ShaderFunction ) + { + IsShaderFunctionWindow = true; + } + else + { + IsShaderFunctionWindow = false; + } + + m_optionsWindow = new OptionsWindow( this ); + m_optionsWindow.Init(); + + m_contextMenu = new GraphContextMenu( m_mainGraphInstance ); + m_nodesLoadedCorrectly = m_contextMenu.CorrectlyLoaded; + + m_paletteWindow = new PaletteWindow( this ) + { + Resizable = true + }; + m_paletteWindow.OnPaletteNodeCreateEvt += OnPaletteNodeCreate; + m_registeredMenus.Add( m_paletteWindow ); + + m_contextPalette = new ContextPalette( this ); + m_contextPalette.OnPaletteNodeCreateEvt += OnContextPaletteNodeCreate; + m_registeredMenus.Add( m_contextPalette ); + + m_genericMessageUI = new GenericMessageUI(); + m_genericMessageUI.OnMessageDisplayEvent += ShowMessageImmediately; + + Selection.selectionChanged += OnProjectSelectionChanged; +#if UNITY_2018_1_OR_NEWER + EditorApplication.projectChanged += OnProjectWindowChanged; +#else + EditorApplication.projectWindowChanged += OnProjectWindowChanged; +#endif + m_focusOnSelectionTimestamp = EditorApplication.timeSinceStartup; + m_focusOnMasterNodeTimestamp = EditorApplication.timeSinceStartup; + + m_nodeParametersWindow.IsMaximized = m_innerEditorVariables.NodeParametersMaximized; + if( DebugConsoleWindow.UseShaderPanelsInfo ) + m_nodeParametersWindow.IsMaximized = m_nodeParametersWindowMaximized; + + m_paletteWindow.IsMaximized = m_innerEditorVariables.NodePaletteMaximized; + if( DebugConsoleWindow.UseShaderPanelsInfo ) + m_paletteWindow.IsMaximized = m_paletteWindowMaximized; + + m_shortcutManager = new ShortcutsManager(); + // REGISTER NODE SHORTCUTS + foreach( KeyValuePair<KeyCode, ShortcutKeyData> kvp in m_contextMenu.NodeShortcuts ) + { + m_shortcutManager.RegisterNodesShortcuts( kvp.Key, kvp.Value.Name ); + } + + // REGISTER EDITOR SHORTCUTS + + m_shortcutManager.RegisterEditorShortcut( true, EventModifiers.FunctionKey, KeyCode.F1, "Open Selected Node Wiki page", () => + { + List<ParentNode> selectedNodes = m_mainGraphInstance.SelectedNodes; + if( selectedNodes != null && selectedNodes.Count == 1 ) + { + Application.OpenURL( selectedNodes[ 0 ].Attributes.NodeUrl ); + } + } ); + + + m_shortcutManager.RegisterEditorShortcut( true, KeyCode.C, "Create Commentary", () => + { + // Create commentary + ParentNode[] selectedNodes = m_mainGraphInstance.SelectedNodes.ToArray(); + UIUtils.MarkUndoAction(); + Undo.RegisterCompleteObjectUndo( this, "Adding Commentary Node" ); + CommentaryNode node = m_mainGraphInstance.CreateNode( m_commentaryTypeNode, true, -1, false ) as CommentaryNode; + node.CreateFromSelectedNodes( TranformedMousePos, selectedNodes ); + node.Focus(); + m_mainGraphInstance.DeSelectAll(); + m_mainGraphInstance.SelectNode( node, false, false ); + SetSaveIsDirty(); + ForceRepaint(); + } ); + + + m_shortcutManager.RegisterEditorShortcut( true, KeyCode.F, "Focus On Selection", () => + { + OnToolButtonPressed( ToolButtonType.FocusOnSelection ); + ForceRepaint(); + } ); + + //m_shortcutManager.RegisterEditorShortcut( true, EventModifiers.None, KeyCode.B, "New Master Node", () => + //{ + // OnToolButtonPressed( ToolButtonType.MasterNode ); + // ForceRepaint(); + //} ); + + m_shortcutManager.RegisterEditorShortcut( true, EventModifiers.None, KeyCode.Space, "Open Node Palette", null, () => + { + m_contextPalette.Show( m_currentMousePos2D, m_cameraInfo ); + } ); + + + m_shortcutManager.RegisterEditorShortcut( true, KeyCode.W, "Toggle Colored Line Mode", () => + { + m_optionsWindow.ColoredPorts = !m_optionsWindow.ColoredPorts; + ForceRepaint(); + + } ); + + m_shortcutManager.RegisterEditorShortcut( true, EventModifiers.Control, KeyCode.W, "Toggle Multi-Line Mode", () => + { + m_optionsWindow.MultiLinePorts = !m_optionsWindow.MultiLinePorts; + ForceRepaint(); + } ); + + m_shortcutManager.RegisterEditorShortcut( true, KeyCode.P, "Global Preview", () => + { + GlobalPreview = !GlobalPreview; + EditorPrefs.SetBool( "GlobalPreview", GlobalPreview ); + + ForceRepaint(); + } ); + + GlobalShowInternalData = EditorPrefs.GetBool( "ASEGlobalShowInternalData", true ); + m_shortcutManager.RegisterEditorShortcut( true, KeyCode.I, "Global Show Internal Data", () => + { + GlobalShowInternalData = !GlobalShowInternalData; + EditorPrefs.SetBool( "ASEGlobalShowInternalData", GlobalShowInternalData ); + ForceRepaint(); + } ); + + m_shortcutManager.RegisterEditorShortcut( true, EventModifiers.FunctionKey, KeyCode.Delete, "Delete selected nodes", DeleteSelectedNodeWithRepaint ); + m_shortcutManager.RegisterEditorShortcut( true, EventModifiers.FunctionKey, KeyCode.Backspace, "Delete selected nodes", DeleteSelectedNodeWithRepaint ); + + m_liveShaderEditing = m_innerEditorVariables.LiveMode; + + UpdateLiveUI(); + } + + + public AmplifyShaderEditorWindow() + { + m_minNodePos = new Vector2( float.MaxValue, float.MaxValue ); + m_maxNodePos = new Vector2( float.MinValue, float.MinValue ); + + m_duplicatePreventionBuffer = new DuplicatePreventionBuffer(); + m_commentaryTypeNode = typeof( CommentaryNode ); + titleContent = new GUIContent( "Shader Editor" ); + autoRepaintOnSceneChange = true; + + m_currentMousePos = new Vector3( 0, 0, 0 ); + m_keyEvtMousePos2D = new Vector2( 0, 0 ); + m_multipleSelectionStart = new Vector2( 0, 0 ); + m_initialized = false; + m_graphBgTexture = null; + m_graphFgTexture = null; + + m_cameraOffset = new Vector2( 0, 0 ); + CameraZoom = 1; + + m_registeredMenus = new List<MenuParent>(); + + m_nodeParametersWindow = new NodeParametersWindow( this ) + { + Resizable = true + }; + m_registeredMenus.Add( m_nodeParametersWindow ); + + m_modeWindow = new ShaderEditorModeWindow( this ); + //_registeredMenus.Add( _modeWindow ); + + m_toolsWindow = new ToolsWindow( this ); + m_toolsWindow.ToolButtonPressedEvt += OnToolButtonPressed; + + m_consoleLogWindow = new ConsoleLogWindow( this ); + + m_tipsWindow = new TipsWindow( this ); + + m_registeredMenus.Add( m_toolsWindow ); + //m_registeredMenus.Add( m_consoleLogWindow ); + + m_palettePopup = new PalettePopUp(); + + m_clipboard = new Clipboard(); + + m_genericMessageContent = new GUIContent(); + m_dragAndDropTool = new DragAndDropTool(); + m_dragAndDropTool.OnValidDropObjectEvt += OnValidObjectsDropped; + + //_confirmationWindow = new ConfirmationWindow( 100, 100, 300, 100 ); + + m_saveIsDirty = false; + + m_preMadeShaders = new PreMadeShaders(); + + Undo.undoRedoPerformed += UndoRedoPerformed; + + float autoPanSpeed = 2; + m_autoPanArea = new AutoPanData[ 4 ]; + m_autoPanArea[ 0 ] = new AutoPanData( AutoPanLocation.TOP, 25, autoPanSpeed * Vector2.up ); + m_autoPanArea[ 1 ] = new AutoPanData( AutoPanLocation.BOTTOM, 25, autoPanSpeed * Vector2.down ); + m_autoPanArea[ 2 ] = new AutoPanData( AutoPanLocation.LEFT, 25, autoPanSpeed * Vector2.right ); + m_autoPanArea[ 3 ] = new AutoPanData( AutoPanLocation.RIGHT, 25, autoPanSpeed * Vector2.left ); + + m_drawInfo = new DrawInfo(); + UIUtils.CurrentWindow = this; + + m_nodeExporterUtils = new NodeExporterUtils( this ); + m_repaintIsDirty = false; + m_initialized = false; + } + + public void SetStandardShader() + { + m_mainGraphInstance.ReplaceMasterNode( AvailableShaderTypes.SurfaceShader ); + m_mainGraphInstance.FireMasterNodeReplacedEvent(); + } + + public void SetTemplateShader( string templateName, bool writeDefaultData ) + { + TemplateDataParent templateData = m_templatesManager.GetTemplate( ( string.IsNullOrEmpty( templateName ) ? "6e114a916ca3e4b4bb51972669d463bf" : templateName ) ); + m_mainGraphInstance.ReplaceMasterNode( AvailableShaderTypes.Template, writeDefaultData, templateData ); + } + + public void DeleteSelectedNodeWithRepaint() + { + DeleteSelectedNodes(); + SetSaveIsDirty(); + } + + + void UndoRedoPerformed() + { + m_repaintIsDirty = true; + m_saveIsDirty = true; + m_removedKeyboardFocus = true; + m_refreshOnUndo = true; + } + + void Destroy() + { + Undo.ClearUndo( this ); + + m_initialized = false; + + m_nodeExporterUtils.Destroy(); + m_nodeExporterUtils = null; + + m_delayedMaterialSet = null; + + m_materialsToUpdate.Clear(); + m_materialsToUpdate = null; + + GLDraw.Destroy(); + + UIUtils.Destroy(); + m_preMadeShaders.Destroy(); + m_preMadeShaders = null; + + m_registeredMenus.Clear(); + m_registeredMenus = null; + + m_mainGraphInstance.Destroy(); + ScriptableObject.DestroyImmediate( m_mainGraphInstance ); + m_mainGraphInstance = null; + + Resources.UnloadAsset( m_graphBgTexture ); + m_graphBgTexture = null; + + Resources.UnloadAsset( m_graphFgTexture ); + m_graphFgTexture = null; + + Resources.UnloadAsset( m_wireTexture ); + m_wireTexture = null; + + m_contextMenu.Destroy(); + m_contextMenu = null; + + m_shortcutManager.Destroy(); + m_shortcutManager = null; + + m_nodeParametersWindow.Destroy(); + m_nodeParametersWindow = null; + + + m_modeWindow.Destroy(); + m_modeWindow = null; + + m_toolsWindow.Destroy(); + m_toolsWindow = null; + + m_consoleLogWindow.Destroy(); + m_consoleLogWindow = null; + + m_tipsWindow.Destroy(); + m_tipsWindow = null; + + m_optionsWindow.Destroy(); + m_optionsWindow = null; + + m_paletteWindow.Destroy(); + m_paletteWindow = null; + + m_palettePopup.Destroy(); + m_palettePopup = null; + + m_contextPalette.Destroy(); + m_contextPalette = null; + + m_clipboard.ClearClipboard(); + m_clipboard = null; + + m_genericMessageUI.Destroy(); + m_genericMessageUI = null; + m_genericMessageContent = null; + + m_dragAndDropTool.Destroy(); + m_dragAndDropTool = null; + + m_openedShaderFunction = null; + + UIUtils.CurrentWindow = null; + m_duplicatePreventionBuffer.ReleaseAllData(); + m_duplicatePreventionBuffer = null; +#if UNITY_2018_1_OR_NEWER + EditorApplication.projectChanged -= OnProjectWindowChanged; +#else + EditorApplication.projectWindowChanged -= OnProjectWindowChanged; +#endif + Selection.selectionChanged -= OnProjectSelectionChanged; + + IOUtils.AllOpenedWindows.Remove( this ); + + if( IOUtils.AllOpenedWindows.Count == 0 ) + { + m_templatesManager.Destroy(); + ScriptableObject.DestroyImmediate( m_templatesManager ); + } + m_templatesManager = null; + + IOUtils.Destroy(); + + Resources.UnloadUnusedAssets(); + GC.Collect(); + } + + void Init() + { + // = AssetDatabase.LoadAssetAtPath( Constants.ASEPath + "", typeof( Texture2D ) ) as Texture2D; + m_graphBgTexture = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( IOUtils.GraphBgTextureGUID ), typeof( Texture2D ) ) as Texture2D; + if( m_graphBgTexture != null ) + { + m_graphFgTexture = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( IOUtils.GraphFgTextureGUID ), typeof( Texture2D ) ) as Texture2D; + + //Setup usable area + m_cameraInfo = position; + m_graphArea = new Rect( 0, 0, m_cameraInfo.width, m_cameraInfo.height ); + + // Creating style state to show current selected object + m_graphFontStyle = new GUIStyle() + { + fontSize = 32, + alignment = TextAnchor.MiddleCenter, + fixedWidth = m_cameraInfo.width, + fixedHeight = 50, + stretchWidth = true, + stretchHeight = true + }; + m_graphFontStyle.normal.textColor = Color.white; + + m_wireTexture = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( IOUtils.WireTextureGUID ), typeof( Texture2D ) ) as Texture2D; + + m_initialized = m_graphBgTexture != null && + m_graphFgTexture != null && + m_wireTexture != null; + } + } +#if UNITY_2018_3_OR_NEWER + + +#endif + [OnOpenAssetAttribute()] + static bool OnOpenAsset( int instanceID, int line ) + { + if( line > -1 ) + { + return false; + } + Preferences.LoadDefaults(); +#if UNITY_2018_3_OR_NEWER + ASEPackageManagerHelper.RequestInfo(); + ASEPackageManagerHelper.Update(); + if( ASEPackageManagerHelper.IsProcessing ) + { + Shader selectedShader = Selection.activeObject as Shader; + if( selectedShader != null ) + { + if( IOUtils.IsASEShader( selectedShader ) ) + { + ASEPackageManagerHelper.SetupLateShader( selectedShader ); + return true; + } + } + else + { + Material mat = Selection.activeObject as Material; + if( mat != null ) + { + if( IOUtils.IsASEShader( mat.shader ) ) + { + ASEPackageManagerHelper.SetupLateMaterial( mat ); + return true; + } + } + else + { + AmplifyShaderFunction shaderFunction = Selection.activeObject as AmplifyShaderFunction; + if( shaderFunction != null ) + { + if( IOUtils.IsShaderFunction( shaderFunction.FunctionInfo ) ) + { + ASEPackageManagerHelper.SetupLateShaderFunction( shaderFunction ); + return true; + } + } + } + } + } + else +#endif + { + Shader selectedShader = Selection.activeObject as Shader; + if( selectedShader != null ) + { + if( IOUtils.IsASEShader( selectedShader ) ) + { + ConvertShaderToASE( selectedShader ); + return true; + } + } + else + { + Material mat = Selection.activeObject as Material; + if( mat != null ) + { + if( IOUtils.IsASEShader( mat.shader ) ) + { + LoadMaterialToASE( mat ); + return true; + } + } + else + { + AmplifyShaderFunction shaderFunction = Selection.activeObject as AmplifyShaderFunction; + if( shaderFunction != null ) + { + if( IOUtils.IsShaderFunction( shaderFunction.FunctionInfo ) ) + { + LoadShaderFunctionToASE( shaderFunction, false ); + return true; + } + } + } + } + } + + return false; + } + + [MenuItem( "Assets/Create/Amplify Shader/Surface", false, 84 )] + [MenuItem( "Assets/Create/Shader/Amplify Surface Shader" )] + static void CreateConfirmationStandardShader() + { + string path = AssetDatabase.GetAssetPath( Selection.activeObject ); + if( path == "" ) + { + path = "Assets"; + } + else if( System.IO.Path.GetExtension( path ) != "" ) + { + path = path.Replace( System.IO.Path.GetFileName( AssetDatabase.GetAssetPath( Selection.activeObject ) ), "" ); + } + + string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath( path + "/New Amplify Shader.shader" ); + var endNameEditAction = ScriptableObject.CreateInstance<DoCreateStandardShader>(); + ProjectWindowUtil.StartNameEditingIfProjectWindowExists( 0, endNameEditAction, assetPathAndName, AssetPreview.GetMiniTypeThumbnail( typeof( Shader ) ), null ); + } + //static void CreateNewShader( ) + //{ + // CreateNewShader( null, null ); + //} + + static void CreateNewShader( string customPath , string customShaderName ) + { + + string path = string.Empty; + if( string.IsNullOrEmpty( customPath ) ) + { + if( Selection.activeObject != null ) + { + path = ( IOUtils.dataPath + AssetDatabase.GetAssetPath( Selection.activeObject ) ); + } + else + { + UnityEngine.Object[] selection = Selection.GetFiltered( typeof( UnityEngine.Object ), SelectionMode.DeepAssets ); + if( selection.Length > 0 && selection[ 0 ] != null ) + { + path = ( IOUtils.dataPath + AssetDatabase.GetAssetPath( selection[ 0 ] ) ); + } + else + { + path = Application.dataPath; + } + + } + + if( path.IndexOf( '.' ) > -1 ) + { + path = path.Substring( 0, path.LastIndexOf( '/' ) ); + } + path += "/"; + } + else + { + path = customPath; + } + + if( IOUtils.AllOpenedWindows.Count > 0 ) + { + EditorWindow openedWindow = AmplifyShaderEditorWindow.GetWindow<AmplifyShaderEditorWindow>(); + AmplifyShaderEditorWindow currentWindow = CreateTab(); + WindowHelper.AddTab( openedWindow, currentWindow ); + UIUtils.CurrentWindow = currentWindow; + Shader shader = UIUtils.CreateNewEmpty( path, customShaderName ); + Selection.activeObject = shader; + } + else + { + AmplifyShaderEditorWindow currentWindow = OpenWindow(); + UIUtils.CurrentWindow = currentWindow; + Shader shader = UIUtils.CreateNewEmpty( path, customShaderName ); + Selection.activeObject = shader; + } + //Selection.objects = new UnityEngine.Object[] { shader }; + } + + public static void CreateConfirmationTemplateShader( string templateGuid ) + { + UIUtils.NewTemplateGUID = templateGuid; + string path = AssetDatabase.GetAssetPath( Selection.activeObject ); + if( path == "" ) + { + path = "Assets"; + } + else if( System.IO.Path.GetExtension( path ) != "" ) + { + path = path.Replace( System.IO.Path.GetFileName( AssetDatabase.GetAssetPath( Selection.activeObject ) ), "" ); + } + + string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath( path + "/New Amplify Shader.shader" ); + var endNameEditAction = ScriptableObject.CreateInstance<DoCreateTemplateShader>(); + ProjectWindowUtil.StartNameEditingIfProjectWindowExists( 0, endNameEditAction, assetPathAndName, AssetPreview.GetMiniTypeThumbnail( typeof( Shader ) ), null ); + } + + public static Shader CreateNewTemplateShader( string templateGUID , string customPath = null, string customShaderName = null ) + { + string path = string.Empty; + if( string.IsNullOrEmpty( customPath ) ) + { + path = Selection.activeObject == null ? Application.dataPath : ( IOUtils.dataPath + AssetDatabase.GetAssetPath( Selection.activeObject ) ); + if( path.IndexOf( '.' ) > -1 ) + { + path = path.Substring( 0, path.LastIndexOf( '/' ) ); + } + path += "/"; + } + else + { + path = customPath; + } + Shader shader = null; + if( IOUtils.AllOpenedWindows.Count > 0 ) + { + EditorWindow openedWindow = AmplifyShaderEditorWindow.GetWindow<AmplifyShaderEditorWindow>(); + AmplifyShaderEditorWindow currentWindow = CreateTab(); + WindowHelper.AddTab( openedWindow, currentWindow ); + UIUtils.CurrentWindow = currentWindow; + shader = UIUtils.CreateNewEmptyTemplate( templateGUID, path, customShaderName ); + Selection.activeObject = shader; + } + else + { + AmplifyShaderEditorWindow currentWindow = OpenWindow(); + UIUtils.CurrentWindow = currentWindow; + shader = UIUtils.CreateNewEmptyTemplate( templateGUID, path, customShaderName ); + Selection.activeObject = shader; + } + + //Selection.objects = new UnityEngine.Object[] { shader }; + return shader; + } + + [MenuItem( "Assets/Create/Amplify Shader Function", false, 84 )] + [MenuItem( "Assets/Create/Shader/Amplify Shader Function" )] + static void CreateNewShaderFunction() + { + AmplifyShaderFunction asset = ScriptableObject.CreateInstance<AmplifyShaderFunction>(); + + string path = AssetDatabase.GetAssetPath( Selection.activeObject ); + if( path == "" ) + { + path = "Assets"; + } + else if( System.IO.Path.GetExtension( path ) != "" ) + { + path = path.Replace( System.IO.Path.GetFileName( AssetDatabase.GetAssetPath( Selection.activeObject ) ), "" ); + } + + string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath( path + "/New ShaderFunction.asset" ); + + var endNameEditAction = ScriptableObject.CreateInstance<DoCreateFunction>(); + ProjectWindowUtil.StartNameEditingIfProjectWindowExists( asset.GetInstanceID(), endNameEditAction, assetPathAndName, AssetPreview.GetMiniThumbnail( asset ), null ); + } + + public void UpdateTabTitle( string newTitle, bool modified ) + { + string[] titleArray = newTitle.Split( '/' ); + newTitle = titleArray[ titleArray.Length - 1 ]; + + if( !( m_currentTitle.Equals( newTitle ) && m_currentTitleMod == modified ) ) + { + this.titleContent.text = GenerateTabTitle( newTitle, modified ); + } + m_currentTitle = newTitle; + m_currentTitleMod = modified; + } + + public void OnProjectWindowChanged() + { + Shader selectedShader = Selection.activeObject as Shader; + if( selectedShader != null ) + { + if( m_mainGraphInstance != null && m_mainGraphInstance.CurrentMasterNode != null && selectedShader == m_mainGraphInstance.CurrentMasterNode.CurrentShader ) + { + m_lastOpenedLocation = AssetDatabase.GetAssetPath( selectedShader ); + } + } + } + + public void LoadProjectSelected( UnityEngine.Object selectedObject = null ) + { + bool hasFocus = true; + if( EditorWindow.focusedWindow != this ) + { + hasFocus = false; + } + + if( hasFocus && m_mainGraphInstance != null && m_mainGraphInstance.CurrentMasterNode != null ) + { + LoadObject( selectedObject ?? Selection.activeObject ); + } + else + { + m_delayedLoadObject = selectedObject ?? Selection.activeObject; + } + + if( !hasFocus ) + Focus(); + } + + public void LoadObject( UnityEngine.Object objToLoad ) + { + Shader selectedShader = objToLoad as Shader; + Material selectedMaterial = objToLoad as Material; + AmplifyShaderFunction selectedFunction = objToLoad as AmplifyShaderFunction; + + if( selectedFunction != null ) + { + IsShaderFunctionWindow = true; + m_mainGraphInstance.CurrentCanvasMode = NodeAvailability.ShaderFunction; + } + else + { + IsShaderFunctionWindow = false; + } + + ASESelectionMode selectedFileType = ASESelectionMode.Shader; + if( selectedShader != null ) + { + selectedFileType = ASESelectionMode.Shader; + } + else if( selectedMaterial != null ) + { + selectedFileType = ASESelectionMode.Material; + } + else if( selectedFunction != null ) + { + selectedFileType = ASESelectionMode.ShaderFunction; + } + + + switch( CurrentSelection ) + { + case ASESelectionMode.Shader: + { + if( ShaderIsModified ) + { + Shader currShader = m_mainGraphInstance.CurrentMasterNode.CurrentShader; + bool savePrevious = UIUtils.DisplayDialog( AssetDatabase.GetAssetPath( currShader ) ); + OnSaveShader( savePrevious, currShader, null, null ); + } + } + break; + case ASESelectionMode.Material: + { + if( ShaderIsModified ) + { + Shader currShader = m_mainGraphInstance.CurrentMasterNode.CurrentShader; + bool savePrevious = UIUtils.DisplayDialog( AssetDatabase.GetAssetPath( currShader ) ); + OnSaveShader( savePrevious, currShader, m_mainGraphInstance.CurrentMasterNode.CurrentMaterial, null ); + } + } + break; + case ASESelectionMode.ShaderFunction: + { + if( ShaderIsModified ) + { + bool savePrevious = UIUtils.DisplayDialog( AssetDatabase.GetAssetPath( m_openedShaderFunction ) ); + OnSaveShader( savePrevious, null, null, selectedFunction ); + } + } + break; + } + + switch( selectedFileType ) + { + case ASESelectionMode.Shader: + { + LoadDroppedObject( true, selectedShader, null ); + } + break; + case ASESelectionMode.Material: + { + LoadDroppedObject( true, selectedMaterial.shader, selectedMaterial ); + } + break; + case ASESelectionMode.ShaderFunction: + { + LoadDroppedObject( true, null, null, selectedFunction ); + } + break; + } + + m_openedShaderFunction = m_mainGraphInstance.CurrentShaderFunction; + + //Need to force one graph draw because it wont call OnGui propertly since its focuses somewhere else + // Focus() doesn't fix this since it only changes keyboard focus + m_drawInfo.InvertedZoom = 1 / m_cameraZoom; + m_mainGraphInstance.Draw( m_drawInfo ); + + ShaderIsModified = false; + Focus(); + Repaint(); + } + + public void OnProjectSelectionChanged() + { + if( m_loadShaderOnSelection ) + { + LoadProjectSelected(); + } + } + + ShaderLoadResult OnSaveShader( bool value, Shader shader, Material material, AmplifyShaderFunction function ) + { + if( value ) + { + SaveToDisk( false ); + } + + return value ? ShaderLoadResult.LOADED : ShaderLoadResult.FILE_NOT_FOUND; + } + + public void ResetCameraSettings() + { + m_cameraInfo = position; + m_cameraOffset = new Vector2( m_cameraInfo.width * 0.5f, m_cameraInfo.height * 0.5f ); + CameraZoom = 1; + } + + public void Reset() + { + if( m_mainGraphInstance == null ) + { + m_mainGraphInstance = CreateInstance<ParentGraph>(); + m_mainGraphInstance.Init(); + m_mainGraphInstance.ParentWindow = this; + m_mainGraphInstance.SetGraphId( 0 ); + } + m_mainGraphInstance.ResetEvents(); + m_mainGraphInstance.OnNodeEvent += OnNodeStoppedMovingEvent; + m_mainGraphInstance.OnMaterialUpdatedEvent += OnMaterialUpdated; + m_mainGraphInstance.OnShaderUpdatedEvent += OnShaderUpdated; + m_mainGraphInstance.OnEmptyGraphDetectedEvt += OnEmptyGraphDetected; + m_mainGraphInstance.OnNodeRemovedEvent += m_toolsWindow.OnNodeRemovedFromGraph; + m_outdatedShaderFromTemplateLoaded = false; + GraphCount = 1; + + FullCleanUndoStack(); + m_performFullUndoRegister = true; + m_toolsWindow.BorderStyle = null; + m_selectionMode = ASESelectionMode.Shader; + ResetCameraSettings(); + UIUtils.ResetMainSkin(); + m_duplicatePreventionBuffer.ReleaseAllData(); + if( m_genericMessageUI != null ) + m_genericMessageUI.CleanUpMessageStack(); + } + + + public Shader CreateNewGraph( string name ) + { + Reset(); + UIUtils.DirtyMask = false; + m_mainGraphInstance.CreateNewEmpty( name ); + m_lastOpenedLocation = string.Empty; + UIUtils.DirtyMask = true; + return m_mainGraphInstance.CurrentMasterNode.CurrentShader; + } + + public Shader CreateNewTemplateGraph( string templateGUID ) + { + Reset(); + UIUtils.DirtyMask = false; + m_mainGraphInstance.CreateNewEmptyTemplate( templateGUID ); + m_lastOpenedLocation = string.Empty; + UIUtils.DirtyMask = true; + return m_mainGraphInstance.CurrentMasterNode.CurrentShader; + } + + public Shader CreateNewGraph( Shader shader ) + { + Reset(); + UIUtils.DirtyMask = false; + m_mainGraphInstance.CreateNewEmpty( shader.name ); + m_mainGraphInstance.CurrentMasterNode.CurrentShader = shader; + + m_lastOpenedLocation = string.Empty; + UIUtils.DirtyMask = true; + return m_mainGraphInstance.CurrentMasterNode.CurrentShader; + } + + public void CreateNewFunctionGraph( AmplifyShaderFunction shaderFunction ) + { + Reset(); + UIUtils.DirtyMask = false; + m_mainGraphInstance.CreateNewEmptyFunction( shaderFunction ); + m_mainGraphInstance.CurrentShaderFunction = shaderFunction; + + m_lastOpenedLocation = AssetDatabase.GetAssetPath( shaderFunction ); //string.Empty; + UIUtils.DirtyMask = true; + //return m_mainGraphInstance.CurrentMasterNode.CurrentShader; + } + + public bool SaveToDisk( bool checkTimestamp ) + { + if( checkTimestamp ) + { + if( !m_cacheSaveOp ) + { + m_lastTimeSaved = EditorApplication.timeSinceStartup; + m_cacheSaveOp = true; + } + return false; + } + + + System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; + + m_customGraph = null; + m_cacheSaveOp = false; + ShaderIsModified = false; + m_mainGraphInstance.LoadedShaderVersion = VersionInfo.FullNumber; + m_lastTimeSaved = EditorApplication.timeSinceStartup; + + if( m_mainGraphInstance.CurrentMasterNodeId == Constants.INVALID_NODE_ID ) + { + Shader currentShader = m_mainGraphInstance.CurrentMasterNode != null ? m_mainGraphInstance.CurrentMasterNode.CurrentShader : null; + string newShader; + if( !String.IsNullOrEmpty( m_lastOpenedLocation ) ) + { + newShader = m_lastOpenedLocation; + } + else if( currentShader != null ) + { + newShader = AssetDatabase.GetAssetPath( currentShader ); + } + else + { + newShader = EditorUtility.SaveFilePanel( "Select Shader to save", Application.dataPath, "MyShader", "shader" ); + } + + if( !String.IsNullOrEmpty( newShader ) ) + { + ShowMessage( "No Master node assigned.\nShader file will only have node info" ); + IOUtils.StartSaveThread( GenerateGraphInfo(), newShader ); + AssetDatabase.Refresh(); + LoadFromDisk( newShader ); + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + return true; + } + } + else if( m_mainGraphInstance.CurrentMasterNode != null ) + { + //m_mainGraphInstance.CurrentStandardSurface.ForceReordering(); + Shader currShader = m_mainGraphInstance.CurrentMasterNode.CurrentShader; + if( currShader != null ) + { + m_mainGraphInstance.FireMasterNode( currShader ); + Material material = m_mainGraphInstance.CurrentMaterial; + m_lastpath = ( material != null ) ? AssetDatabase.GetAssetPath( material ) : AssetDatabase.GetAssetPath( currShader ); + EditorPrefs.SetString( IOUtils.LAST_OPENED_OBJ_ID, m_lastpath ); + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + if( IOUtils.OnShaderSavedEvent != null ) + { + string info = string.Empty; + if( !m_mainGraphInstance.IsStandardSurface ) + { + TemplateMultiPassMasterNode masterNode = m_mainGraphInstance.GetMainMasterNodeOfLOD( -1 ); + if( masterNode != null ) + { + info = masterNode.CurrentTemplate.GUID; + } + } + IOUtils.OnShaderSavedEvent( currShader, !m_mainGraphInstance.IsStandardSurface, info ); + } + return true; + } + else + { + + string shaderName; + string pathName; + IOUtils.GetShaderName( out shaderName, out pathName, Constants.DefaultShaderName, UIUtils.LatestOpenedFolder ); + if( !String.IsNullOrEmpty( pathName ) ) + { + UIUtils.CurrentWindow.CurrentGraph.CurrentMasterNode.SetName( shaderName ); + m_mainGraphInstance.FireMasterNode( pathName, true ); + m_lastpath = pathName; + EditorPrefs.SetString( IOUtils.LAST_OPENED_OBJ_ID, pathName ); + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + return true; + } + } + } + else + { + //m_nodeParametersWindow.ForceReordering(); + m_mainGraphInstance.ResetNodesLocalVariables(); + + List<FunctionInput> functionInputNodes = UIUtils.FunctionInputList(); + functionInputNodes.Sort( ( x, y ) => { return x.OrderIndex.CompareTo( y.OrderIndex ); } ); + for( int i = 0; i < functionInputNodes.Count; i++ ) + { + functionInputNodes[ i ].OrderIndex = i; + } + + List<FunctionOutput> functionOutputNodes = UIUtils.FunctionOutputList(); + functionOutputNodes.Sort( ( x, y ) => { return x.OrderIndex.CompareTo( y.OrderIndex ); } ); + for( int i = 0; i < functionOutputNodes.Count; i++ ) + { + functionOutputNodes[ i ].OrderIndex = i; + } + + m_mainGraphInstance.CurrentShaderFunction.AdditionalDirectives.UpdateSaveItemsFromDirectives(); + m_mainGraphInstance.CurrentShaderFunction.FunctionInfo = GenerateGraphInfo(); + m_mainGraphInstance.CurrentShaderFunction.FunctionInfo = IOUtils.AddAdditionalInfo( m_mainGraphInstance.CurrentShaderFunction.FunctionInfo ); + + if( AssetDatabase.IsMainAsset( m_mainGraphInstance.CurrentShaderFunction ) ) + { + EditorUtility.SetDirty( m_mainGraphInstance.CurrentShaderFunction ); + } + else + { + //Debug.Log( LastOpenedLocation ); + //AssetDatabase.CreateAsset( m_mainGraphInstance.CurrentShaderFunction, LastOpenedLocation ); + } + + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + m_mainGraphInstance.CurrentShaderFunction.AdditionalDirectives.UpdateDirectivesFromSaveItems(); + IOUtils.FunctionNodeChanged = true; + m_lastpath = AssetDatabase.GetAssetPath( m_mainGraphInstance.CurrentShaderFunction ); + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + //EditorPrefs.SetString( IOUtils.LAST_OPENED_OBJ_ID, AssetDatabase.GetAssetPath( m_mainGraphInstance.CurrentShaderFunction ) ); + return true; + } + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + return false; + } + + public void OnToolButtonPressed( ToolButtonType type ) + { + switch( type ) + { + case ToolButtonType.New: + { + UIUtils.CreateNewEmpty(); + } + break; + case ToolButtonType.Open: + { + UIUtils.OpenFile(); + } + break; + case ToolButtonType.Save: + { + SaveToDisk( false ); + } + break; + case ToolButtonType.Library: + { + ShowShaderLibrary(); + } + break; + case ToolButtonType.Options: { } break; + case ToolButtonType.Update: + { + SaveToDisk( false ); + } + break; + case ToolButtonType.Live: + { + m_liveShaderEditing = !m_liveShaderEditing; + m_innerEditorVariables.LiveMode = m_liveShaderEditing; + // 0 off + // 1 on + // 2 pending + if( m_liveShaderEditing && m_mainGraphInstance.CurrentMasterNode != null && m_mainGraphInstance.CurrentMasterNode.CurrentShader == null ) + { + m_liveShaderEditing = false; + m_innerEditorVariables.LiveMode = false; + } + + UpdateLiveUI(); + + if( m_liveShaderEditing ) + { + SaveToDisk( false ); + } + } + break; + case ToolButtonType.OpenSourceCode: + { + AssetDatabase.OpenAsset( m_mainGraphInstance.CurrentMasterNode.CurrentShader, 1 ); + } + break; + case ToolButtonType.MasterNode: + { + m_mainGraphInstance.AssignMasterNode(); + } + break; + + case ToolButtonType.FocusOnMasterNode: + { + double currTime = EditorApplication.timeSinceStartup; + bool autoZoom = ( currTime - m_focusOnMasterNodeTimestamp ) < AutoZoomTime; + m_focusOnMasterNodeTimestamp = currTime; + FocusOnNode( m_mainGraphInstance.CurrentMasterNode, autoZoom ? 1 : m_cameraZoom, true ); + } + break; + + case ToolButtonType.FocusOnSelection: + { + FocusZoom( false, true, true ); + } + break; + case ToolButtonType.ShowInfoWindow: + { + PortLegendInfo.OpenWindow(); + } + break; + case ToolButtonType.ShowTipsWindow: + { + TipsWindow.ShowWindow( true ); + } + break; + case ToolButtonType.ShowConsole: + { + m_consoleLogWindow.Toggle(); + } + break; + case ToolButtonType.Share: + { + List<ParentNode> selectedNodes = m_mainGraphInstance.SelectedNodes; + if( selectedNodes.Count > 0 ) + { + CopyToClipboard(); + StartPasteRequest(); + } + else + { + ShowMessage( "No nodes selected to share" ); + } + } + break; + case ToolButtonType.TakeScreenshot: + { +#if UNITY_EDITOR_WIN + this.Focus(); + m_aseHandle = WindowsUtil.GetActiveWindow(); + //m_aseHandle = FindASEWindowHandle(); + + bool takeit = EditorUtility.DisplayDialog( "Take Screenshot", "This is a work in progress feature that will undock itself if needed, increase the window outside of your screen resolution to take the shot, if something fails (ie: graph too big) you may need to restart Unity, do you wish to continue?", "Yes", "Cancel" ); + if( !takeit ) + break; + + if( this.IsDocked() ) + { + this.Undock(); + this.Focus(); + m_aseHandle = WindowsUtil.GetActiveWindow(); + } + + int windowLong = WindowsUtil.GetWindowLong( m_aseHandle, WindowsUtil.GWL_STYLE ); + + List<ParentNode> selectedNodes = m_mainGraphInstance.AllNodes; + + Vector2 minPos = new Vector2( float.MaxValue, float.MaxValue ); + Vector2 maxPos = new Vector2( float.MinValue, float.MinValue ); + Vector2 centroid = Vector2.zero; + + for( int i = 0; i < selectedNodes.Count; i++ ) + { + Rect currPos = selectedNodes[ i ].TruePosition; + minPos.x = ( currPos.x < minPos.x ) ? currPos.x : minPos.x; + minPos.y = ( currPos.y < minPos.y ) ? currPos.y : minPos.y; + + maxPos.x = ( ( currPos.x + currPos.width ) > maxPos.x ) ? ( currPos.x + currPos.width ) : maxPos.x; + maxPos.y = ( ( currPos.y + currPos.height ) > maxPos.y ) ? ( currPos.y + currPos.height ) : maxPos.y; + } + + centroid = ( maxPos - minPos ); + + m_prevCameraOffset = m_cameraOffset; + m_prevCameraZoom = CameraZoom; + + WindowsUtil.SetWindowLong( m_aseHandle, WindowsUtil.GWL_STYLE, (int)( windowLong & ~( WindowsUtil.WS_SIZEBOX ) ) ); + var rect = new WindowsUtil.Rect(); + WindowsUtil.GetWindowRect( m_aseHandle, ref rect ); + m_prevWindowRect = new Rect( rect.Left, rect.Top, rect.Width, rect.Height ); + + WindowsUtil.SetWindowPos( m_aseHandle, 0, (int)m_prevWindowRect.xMin, (int)m_prevWindowRect.yMin, (int)centroid.x, (int)centroid.y, 0x0040 ); + WindowsUtil.SetWindowLong( m_aseHandle, WindowsUtil.GWL_STYLE, (int)( windowLong ) ); + + m_takeScreenShot = true; +#else + EditorUtility.DisplayDialog( "Take Screenshot", "This is a work in progress feature that only works in Windows environment", "Ok" ); +#endif + } + break; + case ToolButtonType.CleanUnusedNodes: + { + m_mainGraphInstance.CleanUnusedNodes(); + } + break; + case ToolButtonType.Help: + { + Application.OpenURL( Constants.HelpURL ); + } + break; + } + } + +#if UNITY_EDITOR_WIN + IntPtr FindASEWindowHandle() + { + System.Diagnostics.Process process = System.Diagnostics.Process.GetCurrentProcess(); + + IntPtr[] winPtrs = WindowsUtil.GetProcessWindows( process.Id ); + m_aseHandle = IntPtr.Zero; + bool found = false; + for( int i = 0; i < winPtrs.Length; i++ ) + { + WindowsUtil.EnumChildWindows( winPtrs[ i ], delegate ( System.IntPtr hwnd, System.IntPtr param ) + { + System.Text.StringBuilder Title = new System.Text.StringBuilder( 256 ); + WindowsUtil.GetWindowText( hwnd, Title, Title.Capacity ); + + if( Title.ToString().Contains( "AmplifyShaderEditor.AmplifyShaderEditorWindow" ) ) + { + if( !found ) + { + m_aseHandle = winPtrs[ i ]; + found = true; + } + } + + return true; + }, System.IntPtr.Zero ); + } + + return m_aseHandle; + } + + void OpenSavedFolder() + { + m_openSavedFolder = false; + + var path = System.IO.Path.GetFullPath( Application.dataPath + "\\..\\ScreenshotASE.png" ); + EditorUtility.RevealInFinder( path ); + GUIUtility.ExitGUI(); + } + + void TakeScreenShot() + { + m_takeScreenShot = false; + + var cacher = RenderTexture.active; + RenderTexture.active = null; + + Texture2D m_screenshotTex2D = new Texture2D( (int)position.width, (int)position.height, TextureFormat.RGB24, false ); + m_screenshotTex2D.ReadPixels( new Rect( 0, 0, m_screenshotTex2D.width, m_screenshotTex2D.height ), 0, 0 ); + m_screenshotTex2D.Apply(); + + byte[] bytes = m_screenshotTex2D.EncodeToPNG(); + + var path = System.IO.Path.GetFullPath( Application.dataPath + "\\..\\ScreenshotASE.png" ); + System.IO.File.WriteAllBytes( path, bytes ); + + RenderTexture.active = cacher; + + ShowMessage( "[AmplifyShaderEditor] Screenshot successfully taken and saved at: " + path, consoleLog:true ); + + WindowsUtil.SetWindowPos( m_aseHandle, 0, (int)m_prevWindowRect.xMin, (int)m_prevWindowRect.yMin, (int)m_prevWindowRect.width, (int)m_prevWindowRect.height, 0x0040 ); + m_cameraOffset = m_prevCameraOffset; + CameraZoom = m_prevCameraZoom; + + m_openSavedFolder = true; + } +#endif + + + void UpdateLiveUI() + { + if( m_toolsWindow != null ) + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Live, ( m_liveShaderEditing ) ? 1 : 0 ); + } + } + + void FocusZoom( bool forceAllNodes, bool doubleTap, bool smooth = true ) + { + List<ParentNode> selectedNodes = ( m_mainGraphInstance.SelectedNodes.Count > 0 ) && !forceAllNodes ? m_mainGraphInstance.SelectedNodes : m_mainGraphInstance.AllNodes; + + Vector2 minPos = new Vector2( float.MaxValue, float.MaxValue ); + Vector2 maxPos = new Vector2( float.MinValue, float.MinValue ); + Vector2 centroid = Vector2.zero; + + for( int i = 0; i < selectedNodes.Count; i++ ) + { + Rect currPos = selectedNodes[ i ].TruePosition; + + minPos.x = ( currPos.x < minPos.x ) ? currPos.x : minPos.x; + minPos.y = ( currPos.y < minPos.y ) ? currPos.y : minPos.y; + + maxPos.x = ( ( currPos.x + currPos.width ) > maxPos.x ) ? ( currPos.x + currPos.width ) : maxPos.x; + maxPos.y = ( ( currPos.y + currPos.height ) > maxPos.y ) ? ( currPos.y + currPos.height ) : maxPos.y; + + } + + centroid = ( maxPos - minPos ); + + double currTime = EditorApplication.timeSinceStartup; + bool autoZoom = ( currTime - m_focusOnSelectionTimestamp ) < AutoZoomTime; + if( !doubleTap ) + autoZoom = true; + m_focusOnSelectionTimestamp = currTime; + + float zoom = m_cameraZoom; + if( autoZoom ) + { + zoom = 1f; + float canvasWidth = m_cameraInfo.width; + if( m_nodeParametersWindow.IsMaximized ) + canvasWidth -= m_nodeParametersWindow.RealWidth; + if( m_paletteWindow.IsMaximized ) + canvasWidth -= m_paletteWindow.RealWidth; + canvasWidth -= 40; + //float canvasWidth = AvailableCanvasWidth;// - 20; + float canvasHeight = AvailableCanvasHeight - 60; + if( centroid.x > canvasWidth || + centroid.y > canvasHeight ) + { + float hZoom = float.MinValue; + float vZoom = float.MinValue; + if( centroid.x > canvasWidth ) + { + hZoom = ( centroid.x ) / canvasWidth; + } + + if( centroid.y > canvasHeight ) + { + vZoom = ( centroid.y ) / canvasHeight; + } + zoom = ( hZoom > vZoom ) ? hZoom : vZoom; + } + } + + minPos.y -= 20 * zoom; + if( m_nodeParametersWindow.IsMaximized ) + minPos.x -= m_nodeParametersWindow.RealWidth * 0.5f * zoom; + if( m_paletteWindow.IsMaximized ) + minPos.x += m_paletteWindow.RealWidth * 0.5f * zoom; + + FocusOnPoint( minPos + centroid * 0.5f, zoom, smooth ); + } + + public void FocusOnNode( int nodeId, float zoom, bool selectNode, bool late = false ) + { + ParentNode node = m_mainGraphInstance.GetNode( nodeId ); + if( node != null ) + { + FocusOnNode( node, zoom, selectNode, late ); + } + } + + public void FocusOnNode( ParentNode node, float zoom, bool selectNode, bool late = false ) + { + if( late ) + { + m_nodeToFocus = node; + m_zoomToFocus = zoom; + m_selectNodeToFocus = selectNode; + return; + } + + if( selectNode ) + { + m_mainGraphInstance.SelectNode( node, false, false ); + } + + Vector2 nodePoint = node.CenterPosition; + nodePoint.x = nodePoint.x - ( m_nodeParametersWindow.RealWidth * 0.5f + m_paletteWindow.RealWidth * 0.5f ) * ( zoom > 0.999f ? zoom : CameraZoom ); + FocusOnPoint( nodePoint, zoom ); + } + + public void FocusOnPoint( Vector2 point, float zoom, bool smooth = true ) + { + if( zoom > 0.999f ) + { + if( smooth ) + SmoothZoom( zoom ); + else + CameraZoom = zoom; + } + + if( smooth ) + SmoothCameraOffset( -point + new Vector2( ( m_cameraInfo.width ) * 0.5f, m_cameraInfo.height * 0.5f ) * CameraZoom ); + else + m_cameraOffset = -point + new Vector2( ( m_cameraInfo.width ) * 0.5f, m_cameraInfo.height * 0.5f ) * CameraZoom; + } + + void SmoothZoom( float newZoom ) + { + m_smoothZoom = true; + m_zoomTime = 0; + m_targetZoom = newZoom; + m_zoomPivot = m_graphArea.center; + } + + void SmoothCameraOffset( Vector2 newOffset ) + { + m_smoothOffset = true; + m_offsetTime = 0; + m_targetOffset = newOffset; + } + + void PreTestLeftMouseDown() + { + if( m_currentEvent.type == EventType.MouseDown && m_currentEvent.button == ButtonClickId.LeftMouseButton ) + { + ParentNode node = m_mainGraphInstance.CheckNodeAt( m_currentMousePos ); + if( node != null ) + { + m_mainGraphInstance.NodeClicked = node.UniqueId; + return; + } + } + + m_mainGraphInstance.NodeClicked = -1; + } + + + + void OnLeftMouseDown() + { + Focus(); + + if( m_lastKeyPressed == KeyCode.Q ) + { + m_rmbStartPos = m_currentMousePos2D; + UseCurrentEvent(); + return; + } + + m_mouseDownOnValidArea = true; + m_lmbPressed = true; + if( m_currentEvent.alt ) + { + m_altBoxSelection = true; + } + + UIUtils.ShowContextOnPick = true; + ParentNode node = ( m_mainGraphInstance.NodeClicked < 0 ) ? m_mainGraphInstance.CheckNodeAt( m_currentMousePos ) : m_mainGraphInstance.GetClickedNode(); + if( node != null ) + { + m_mainGraphInstance.NodeClicked = node.UniqueId; + m_altBoxSelection = false; + + if( m_contextMenu.CheckShortcutKey() ) + { + if( node.ConnStatus == NodeConnectionStatus.Island ) + { + if( !m_multipleSelectionActive ) + { + ParentNode newNode = m_contextMenu.CreateNodeFromShortcutKey(); + if( newNode != null ) + { + newNode.ContainerGraph = m_mainGraphInstance; + newNode.Vec2Position = TranformedMousePos; + m_mainGraphInstance.AddNode( newNode, true ); + m_mainGraphInstance.SelectNode( newNode, false, false ); + ForceRepaint(); + } + ( node as CommentaryNode ).AddNodeToCommentary( newNode ); + } + } + } + else + { + if( node.OnClick( m_currentMousePos2D ) ) + { + if( !node.Selected ) + { + m_mainGraphInstance.SelectNode( node, ( m_currentEvent.modifiers == EventModifiers.Shift || m_currentEvent.modifiers == EventModifiers.Control ), true ); + } + else if( m_currentEvent.modifiers == EventModifiers.Shift || m_currentEvent.modifiers == EventModifiers.Control ) + { + m_mainGraphInstance.DeselectNode( node ); + } + + if( m_currentEvent.alt ) + { + int conn = 0; + for( int i = 0; i < node.InputPorts.Count; i++ ) + { + if( node.InputPorts[ i ].IsConnected ) + conn++; + } + + if( node.InputPorts.Count > 0 && node.OutputPorts.Count > 0 && conn > 0 && node.OutputPorts[ 0 ].IsConnected ) + { + m_altDragStarted = true; + } + } + + } + + if( m_currentEvent.alt ) + { + if( node.InputPorts.Count > 0 && node.OutputPorts.Count > 0 && node.InputPorts[ 0 ].IsConnected && node.OutputPorts[ 0 ].IsConnected ) + { + m_altDragStarted = true; + } + } + + return; + } + } + else if( !m_multipleSelectionActive ) + { + ParentNode newNode = m_contextMenu.CreateNodeFromShortcutKey(); + if( newNode != null ) + { + newNode.ContainerGraph = m_mainGraphInstance; + newNode.Vec2Position = TranformedMousePos; + m_mainGraphInstance.AddNode( newNode, true ); + m_mainGraphInstance.SelectNode( newNode, false, false ); + SetSaveIsDirty(); + ForceRepaint(); + } + else + { + List<WireBezierReference> wireRefs = m_mainGraphInstance.GetWireBezierListInPos( m_currentMousePos2D ); + if( wireRefs != null && wireRefs.Count > 0 ) + { + for( int i = 0; i < wireRefs.Count; i++ ) + { + // Place wire code here + ParentNode outNode = m_mainGraphInstance.GetNode( wireRefs[ i ].OutNodeId ); + ParentNode inNode = m_mainGraphInstance.GetNode( wireRefs[ i ].InNodeId ); + + OutputPort outputPort = outNode.GetOutputPortByUniqueId( wireRefs[ i ].OutPortId ); + InputPort inputPort = inNode.GetInputPortByUniqueId( wireRefs[ i ].InPortId ); + + // Calculate the 4 points for bezier taking into account wire nodes and their automatic tangents + Vector3 endPos = new Vector3( inputPort.Position.x, inputPort.Position.y ); + Vector3 startPos = new Vector3( outputPort.Position.x, outputPort.Position.y ); + + float mag = ( endPos - startPos ).magnitude; + float resizedMag = Mathf.Min( mag, Constants.HORIZONTAL_TANGENT_SIZE * m_drawInfo.InvertedZoom ); + + Vector3 startTangent = new Vector3( startPos.x + resizedMag, startPos.y ); + Vector3 endTangent = new Vector3( endPos.x - resizedMag, endPos.y ); + + if( inNode != null && inNode.GetType() == typeof( WireNode ) ) + endTangent = endPos + ( ( inNode as WireNode ).TangentDirection ) * mag * 0.33f; + + if( outNode != null && outNode.GetType() == typeof( WireNode ) ) + startTangent = startPos - ( ( outNode as WireNode ).TangentDirection ) * mag * 0.33f; + + float dist = HandleUtility.DistancePointBezier( m_currentMousePos, startPos, endPos, startTangent, endTangent ); + if( dist < 10 ) + { + double doubleTapTime = EditorApplication.timeSinceStartup; + bool doubleTap = ( doubleTapTime - m_wiredDoubleTapTimestamp ) < WiredDoubleTapTime; + m_wiredDoubleTapTimestamp = doubleTapTime; + + if( doubleTap ) + { + Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateConnectionId ); + Undo.RegisterCompleteObjectUndo( m_mainGraphInstance, Constants.UndoCreateConnectionId ); + Undo.RecordObject( outNode, Constants.UndoCreateConnectionId ); + Undo.RecordObject( inNode, Constants.UndoCreateConnectionId ); + + ParentNode wireNode = m_mainGraphInstance.CreateNode( typeof( WireNode ), true ); + if( wireNode != null ) + { + wireNode.Vec2Position = TranformedMousePos; + + m_mainGraphInstance.CreateConnection( wireNode.InputPorts[ 0 ].NodeId, wireNode.InputPorts[ 0 ].PortId, outputPort.NodeId, outputPort.PortId ); + m_mainGraphInstance.CreateConnection( inputPort.NodeId, inputPort.PortId, wireNode.OutputPorts[ 0 ].NodeId, wireNode.OutputPorts[ 0 ].PortId ); + + SetSaveIsDirty(); + ForceRepaint(); + Undo.IncrementCurrentGroup(); + } + } + + break; + } + } + } + //Reset focus from any textfield which may be selected at this time + GUIUtility.keyboardControl = 0; + } + } + + if( m_currentEvent.modifiers != EventModifiers.Shift && m_currentEvent.modifiers != EventModifiers.Control && !m_altBoxSelection ) + m_mainGraphInstance.DeSelectAll(); + + if( m_wireReferenceUtils.ValidReferences() ) + { + m_wireReferenceUtils.InvalidateReferences(); + return; + } + + if( !m_contextMenu.CheckShortcutKey() && m_currentEvent.modifiers != EventModifiers.Shift && m_currentEvent.modifiers != EventModifiers.Control || m_altBoxSelection ) + { + // Only activate multiple selection if no node is selected and shift key not pressed + m_multipleSelectionActive = true; + + m_multipleSelectionStart = TranformedMousePos; + m_multipleSelectionArea.position = m_multipleSelectionStart; + m_multipleSelectionArea.size = Vector2.zero; + } + + UseCurrentEvent(); + } + + void OnLeftMouseDrag() + { + if( m_lostFocus ) + { + m_lostFocus = false; + return; + } + + if( m_lastKeyPressed == KeyCode.Q ) + { + if( m_currentEvent.alt ) + { + ModifyZoom( Constants.ALT_CAMERA_ZOOM_SPEED * ( m_currentEvent.delta.x + m_currentEvent.delta.y ), m_altKeyStartPos ); + } + else + { + m_cameraOffset += m_cameraZoom * m_currentEvent.delta; + } + UseCurrentEvent(); + return; + } + + if( m_altDragStarted ) + { + m_altDragStarted = false; + + if( m_currentEvent.modifiers == EventModifiers.Alt && CurrentGraph.SelectedNodes.Count == 1 ) + { + ParentNode node = CurrentGraph.SelectedNodes[ 0 ]; + int lastId = 0; + int conn = 0; + for( int i = 0; i < node.InputPorts.Count; i++ ) + { + if( node.InputPorts[ i ].IsConnected ) + { + conn++; + lastId = i; + } + } + + if( conn > 1 ) + lastId = 0; + + + + OutputPort outputPort = node.InputPorts[ lastId ].GetOutputConnection( 0 ); + ParentNode outputNode = m_mainGraphInstance.GetNode( outputPort.NodeId ); + bool outputIsWireNode = outputNode is WireNode; + + Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateConnectionId ); + node.RecordObject( Constants.UndoCreateConnectionId ); + outputNode.RecordObject( Constants.UndoCreateConnectionId ); + + List<InputPort> inputPorts = new List<InputPort>(); + for( int i = 0; i < node.OutputPorts[ 0 ].ConnectionCount; i++ ) + { + InputPort inputPort = node.OutputPorts[ 0 ].GetInputConnection( i ); + ParentNode inputNode = m_mainGraphInstance.GetNode( inputPort.NodeId ); + inputNode.RecordObject( Constants.UndoCreateConnectionId ); + inputPorts.Add( inputPort ); + } + + for( int i = 0; i < inputPorts.Count; i++ ) + { + if( outputIsWireNode ) + { + if( i == 0 ) + { + m_mainGraphInstance.CreateConnection( inputPorts[ i ].NodeId, inputPorts[ i ].PortId, outputPort.NodeId, outputPort.PortId ); + } + else + { + UIUtils.DeleteConnection( true, inputPorts[ i ].NodeId, inputPorts[ i ].PortId, false, true ); + } + } + else + { + m_mainGraphInstance.CreateConnection( inputPorts[ i ].NodeId, inputPorts[ i ].PortId, outputPort.NodeId, outputPort.PortId ); + } + } + + UIUtils.DeleteConnection( true, node.UniqueId, node.InputPorts[ lastId ].PortId, false, true ); + + SetSaveIsDirty(); + ForceRepaint(); + } + } + + if( !m_wireReferenceUtils.ValidReferences() && !m_altBoxSelection ) + { + if( m_mouseDownOnValidArea && m_insideEditorWindow ) + { + if( m_currentEvent.control ) + { + m_mainGraphInstance.MoveSelectedNodes( m_cameraZoom * m_currentEvent.delta, true ); + } + else + { + m_mainGraphInstance.MoveSelectedNodes( m_cameraZoom * m_currentEvent.delta ); + } + //m_mainGraphInstance.MoveSelectedNodes( m_cameraZoom * m_currentEvent.delta ); + m_autoPanDirActive = true; + } + } + else + { + List<ParentNode> nodes = m_mainGraphInstance.GetNodesInGrid( m_drawInfo.TransformedMousePos ); + if( nodes != null && nodes.Count > 0 ) + { + Vector2 currentPortPos = new Vector2(); + Vector2 mousePos = TranformedMousePos; + + if( m_wireReferenceUtils.InputPortReference.IsValid ) + { + OutputPort currentPort = null; + float smallestDistance = float.MaxValue; + Vector2 smallestPosition = Vector2.zero; + for( int nodeIdx = 0; nodeIdx < nodes.Count; nodeIdx++ ) + { + List<OutputPort> outputPorts = nodes[ nodeIdx ].OutputPorts; + if( outputPorts != null ) + { + for( int o = 0; o < outputPorts.Count; o++ ) + { + if( outputPorts[ o ].Available ) + { + currentPortPos.x = outputPorts[ o ].Position.x; + currentPortPos.y = outputPorts[ o ].Position.y; + + currentPortPos = currentPortPos * m_cameraZoom - m_cameraOffset; + float dist = ( mousePos - currentPortPos ).sqrMagnitude; + if( dist < smallestDistance ) + { + smallestDistance = dist; + smallestPosition = currentPortPos; + currentPort = outputPorts[ o ]; + } + } + } + } + } + + if( currentPort != null && currentPort.Available && ( smallestDistance < Constants.SNAP_SQR_DIST || currentPort.InsideActiveArea( ( mousePos + m_cameraOffset ) / m_cameraZoom ) ) ) + { + m_wireReferenceUtils.ActivateSnap( smallestPosition, currentPort ); + } + else + { + m_wireReferenceUtils.DeactivateSnap(); + } + } + + if( m_wireReferenceUtils.OutputPortReference.IsValid ) + { + InputPort currentPort = null; + float smallestDistance = float.MaxValue; + Vector2 smallestPosition = Vector2.zero; + for( int nodeIdx = 0; nodeIdx < nodes.Count; nodeIdx++ ) + { + List<InputPort> inputPorts = nodes[ nodeIdx ].InputPorts; + if( inputPorts != null ) + { + for( int i = 0; i < inputPorts.Count; i++ ) + { + if( inputPorts[ i ].Available ) + { + currentPortPos.x = inputPorts[ i ].Position.x; + currentPortPos.y = inputPorts[ i ].Position.y; + + currentPortPos = currentPortPos * m_cameraZoom - m_cameraOffset; + float dist = ( mousePos - currentPortPos ).sqrMagnitude; + if( dist < smallestDistance ) + { + smallestDistance = dist; + smallestPosition = currentPortPos; + currentPort = inputPorts[ i ]; + } + } + } + } + } + if( currentPort != null && currentPort.Available && ( smallestDistance < Constants.SNAP_SQR_DIST || currentPort.InsideActiveArea( ( mousePos + m_cameraOffset ) / m_cameraZoom ) ) ) + { + m_wireReferenceUtils.ActivateSnap( smallestPosition, currentPort ); + } + else + { + m_wireReferenceUtils.DeactivateSnap(); + } + } + } + else if( m_wireReferenceUtils.SnapEnabled ) + { + m_wireReferenceUtils.DeactivateSnap(); + } + } + UseCurrentEvent(); + } + + public void OnLeftMouseUp() + { + m_lmbPressed = false; + if( m_multipleSelectionActive ) + { + //m_multipleSelectionActive = false; + UpdateSelectionArea(); + //m_mainGraphInstance.MultipleSelection( m_multipleSelectionArea, ( m_currentEvent.modifiers == EventModifiers.Shift || m_currentEvent.modifiers == EventModifiers.Control ), true ); + if( m_currentEvent.alt && m_altBoxSelection ) + { + m_mainGraphInstance.MultipleSelection( m_multipleSelectionArea, !m_currentEvent.shift ); + } + else + { + m_mainGraphInstance.DeSelectAll(); + m_mainGraphInstance.MultipleSelection( m_multipleSelectionArea ); + } + } + + if( m_wireReferenceUtils.ValidReferences() ) + { + //Check if there is some kind of port beneath the mouse ... if so connect to it + ParentNode targetNode = m_wireReferenceUtils.SnapEnabled ? m_mainGraphInstance.GetNode( m_wireReferenceUtils.SnapPort.NodeId ) : m_mainGraphInstance.CheckNodeAt( m_currentMousePos ); + if( targetNode != null && targetNode.ConnStatus != NodeConnectionStatus.Island ) + { + if( m_wireReferenceUtils.InputPortReference.IsValid && m_wireReferenceUtils.InputPortReference.NodeId != targetNode.UniqueId ) + { + OutputPort outputPort = m_wireReferenceUtils.SnapEnabled ? targetNode.GetOutputPortByUniqueId( m_wireReferenceUtils.SnapPort.PortId ) : targetNode.CheckOutputPortAt( m_currentMousePos ); + if( outputPort != null && !outputPort.Locked && ( !m_wireReferenceUtils.InputPortReference.TypeLocked || + m_wireReferenceUtils.InputPortReference.DataType == WirePortDataType.OBJECT || + ( m_wireReferenceUtils.InputPortReference.TypeLocked && outputPort.DataType == m_wireReferenceUtils.InputPortReference.DataType ) ) ) + { + + ParentNode originNode = m_mainGraphInstance.GetNode( m_wireReferenceUtils.InputPortReference.NodeId ); + InputPort inputPort = originNode.GetInputPortByUniqueId( m_wireReferenceUtils.InputPortReference.PortId ); + UIUtils.MarkUndoAction(); + Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateConnectionId ); + originNode.RecordObject( Constants.UndoCreateConnectionId ); + targetNode.RecordObject( Constants.UndoCreateConnectionId ); + + if( !inputPort.CheckValidType( outputPort.DataType ) ) + { + UIUtils.ShowIncompatiblePortMessage( true, originNode, inputPort, targetNode, outputPort ); + m_wireReferenceUtils.InvalidateReferences(); + UseCurrentEvent(); + return; + } + + if( !outputPort.CheckValidType( inputPort.DataType ) ) + { + UIUtils.ShowIncompatiblePortMessage( false, targetNode, outputPort, originNode, inputPort ); + m_wireReferenceUtils.InvalidateReferences(); + UseCurrentEvent(); + return; + } + + inputPort.DummyAdd( outputPort.NodeId, outputPort.PortId ); + outputPort.DummyAdd( m_wireReferenceUtils.InputPortReference.NodeId, m_wireReferenceUtils.InputPortReference.PortId ); + + if( UIUtils.DetectNodeLoopsFrom( originNode, new Dictionary<int, int>() ) ) + { + inputPort.DummyRemove(); + outputPort.DummyRemove(); + m_wireReferenceUtils.InvalidateReferences(); + ShowMessage( "Infinite Loop detected" ); + UseCurrentEvent(); + return; + } + + inputPort.DummyRemove(); + outputPort.DummyRemove(); + + if( inputPort.IsConnected ) + { + DeleteConnection( true, m_wireReferenceUtils.InputPortReference.NodeId, m_wireReferenceUtils.InputPortReference.PortId, true, false ); + } + + //link output to input + if( outputPort.ConnectTo( m_wireReferenceUtils.InputPortReference.NodeId, m_wireReferenceUtils.InputPortReference.PortId, m_wireReferenceUtils.InputPortReference.DataType, m_wireReferenceUtils.InputPortReference.TypeLocked ) ) + targetNode.OnOutputPortConnected( outputPort.PortId, m_wireReferenceUtils.InputPortReference.NodeId, m_wireReferenceUtils.InputPortReference.PortId ); + + //link input to output + if( inputPort.ConnectTo( outputPort.NodeId, outputPort.PortId, outputPort.DataType, m_wireReferenceUtils.InputPortReference.TypeLocked ) ) + originNode.OnInputPortConnected( m_wireReferenceUtils.InputPortReference.PortId, targetNode.UniqueId, outputPort.PortId ); + m_mainGraphInstance.MarkWireHighlights(); + } + else if( outputPort != null && m_wireReferenceUtils.InputPortReference.TypeLocked && m_wireReferenceUtils.InputPortReference.DataType != outputPort.DataType ) + { + ShowMessage( "Attempting to connect a port locked to type " + m_wireReferenceUtils.InputPortReference.DataType + " into a port of type " + outputPort.DataType ); + } + ShaderIsModified = true; + SetSaveIsDirty(); + } + + if( m_wireReferenceUtils.OutputPortReference.IsValid && m_wireReferenceUtils.OutputPortReference.NodeId != targetNode.UniqueId ) + { + InputPort inputPort = m_wireReferenceUtils.SnapEnabled ? targetNode.GetInputPortByUniqueId( m_wireReferenceUtils.SnapPort.PortId ) : targetNode.CheckInputPortAt( m_currentMousePos ); + if( inputPort != null && !inputPort.Locked && ( !inputPort.TypeLocked || + inputPort.DataType == WirePortDataType.OBJECT || + ( inputPort.TypeLocked && inputPort.DataType == m_wireReferenceUtils.OutputPortReference.DataType ) ) ) + { + ParentNode originNode = m_mainGraphInstance.GetNode( m_wireReferenceUtils.OutputPortReference.NodeId ); + OutputPort outputPort = originNode.GetOutputPortByUniqueId( m_wireReferenceUtils.OutputPortReference.PortId ); + + UIUtils.MarkUndoAction(); + Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateConnectionId ); + originNode.RecordObject( Constants.UndoCreateConnectionId ); + targetNode.RecordObject( Constants.UndoCreateConnectionId ); + + if( !inputPort.CheckValidType( outputPort.DataType ) ) + { + UIUtils.ShowIncompatiblePortMessage( true, targetNode, inputPort, originNode, outputPort ); + m_wireReferenceUtils.InvalidateReferences(); + UseCurrentEvent(); + return; + } + + if( !outputPort.CheckValidType( inputPort.DataType ) ) + { + UIUtils.ShowIncompatiblePortMessage( false, originNode, outputPort, targetNode, inputPort ); + m_wireReferenceUtils.InvalidateReferences(); + UseCurrentEvent(); + return; + } + + inputPort.DummyAdd( m_wireReferenceUtils.OutputPortReference.NodeId, m_wireReferenceUtils.OutputPortReference.PortId ); + outputPort.DummyAdd( inputPort.NodeId, inputPort.PortId ); + if( UIUtils.DetectNodeLoopsFrom( targetNode, new Dictionary<int, int>() ) ) + { + inputPort.DummyRemove(); + outputPort.DummyRemove(); + m_wireReferenceUtils.InvalidateReferences(); + ShowMessage( "Infinite Loop detected" ); + UseCurrentEvent(); + return; + } + + inputPort.DummyRemove(); + outputPort.DummyRemove(); + + if( inputPort.IsConnected ) + { + if( m_currentEvent.control && m_wireReferenceUtils.SwitchPortReference.IsValid ) + { + ParentNode oldOutputNode = UIUtils.GetNode( inputPort.GetConnection( 0 ).NodeId ); + OutputPort oldOutputPort = oldOutputNode.GetOutputPortByUniqueId( inputPort.GetConnection( 0 ).PortId ); + + ParentNode switchNode = UIUtils.GetNode( m_wireReferenceUtils.SwitchPortReference.NodeId ); + InputPort switchPort = switchNode.GetInputPortByUniqueId( m_wireReferenceUtils.SwitchPortReference.PortId ); + + switchPort.DummyAdd( oldOutputPort.NodeId, oldOutputPort.PortId ); + oldOutputPort.DummyAdd( switchPort.NodeId, switchPort.PortId ); + if( UIUtils.DetectNodeLoopsFrom( switchNode, new Dictionary<int, int>() ) ) + { + switchPort.DummyRemove(); + oldOutputPort.DummyRemove(); + m_wireReferenceUtils.InvalidateReferences(); + ShowMessage( "Infinite Loop detected" ); + UseCurrentEvent(); + return; + } + + switchPort.DummyRemove(); + oldOutputPort.DummyRemove(); + + DeleteConnection( true, inputPort.NodeId, inputPort.PortId, true, false ); + ConnectInputToOutput( switchPort.NodeId, switchPort.PortId, oldOutputPort.NodeId, oldOutputPort.PortId ); + } + else + { + DeleteConnection( true, inputPort.NodeId, inputPort.PortId, true, false ); + } + } + inputPort.InvalidateAllConnections(); + + + //link input to output + if( inputPort.ConnectTo( m_wireReferenceUtils.OutputPortReference.NodeId, m_wireReferenceUtils.OutputPortReference.PortId, m_wireReferenceUtils.OutputPortReference.DataType, inputPort.TypeLocked ) ) + targetNode.OnInputPortConnected( inputPort.PortId, m_wireReferenceUtils.OutputPortReference.NodeId, m_wireReferenceUtils.OutputPortReference.PortId ); + //link output to input + + if( outputPort.ConnectTo( inputPort.NodeId, inputPort.PortId, inputPort.DataType, inputPort.TypeLocked ) ) + originNode.OnOutputPortConnected( m_wireReferenceUtils.OutputPortReference.PortId, targetNode.UniqueId, inputPort.PortId ); + m_mainGraphInstance.MarkWireHighlights(); + } + else if( inputPort != null && inputPort.TypeLocked && inputPort.DataType != m_wireReferenceUtils.OutputPortReference.DataType ) + { + ShowMessage( "Attempting to connect a " + m_wireReferenceUtils.OutputPortReference.DataType + " to a port locked to type " + inputPort.DataType ); + } + ShaderIsModified = true; + SetSaveIsDirty(); + } + m_wireReferenceUtils.InvalidateReferences(); + } + else + { + if( UIUtils.ShowContextOnPick ) + m_contextPalette.Show( m_currentMousePos2D, m_cameraInfo ); + else + m_wireReferenceUtils.InvalidateReferences(); + } + } + else if( m_currentEvent.modifiers == EventModifiers.Alt && m_altAvailable && CurrentGraph.SelectedNodes.Count == 1 && !m_altBoxSelection && !m_multipleSelectionActive ) + { + List<WireBezierReference> wireRefs = m_mainGraphInstance.GetWireBezierListInPos( m_currentMousePos2D ); + if( wireRefs != null && wireRefs.Count > 0 ) + { + float closestDist = 50; + int closestId = 0; + + for( int i = 0; i < wireRefs.Count; i++ ) + { + ParentNode outNode = m_mainGraphInstance.GetNode( wireRefs[ i ].OutNodeId ); + ParentNode inNode = m_mainGraphInstance.GetNode( wireRefs[ i ].InNodeId ); + + if( outNode == CurrentGraph.SelectedNodes[ 0 ] || inNode == CurrentGraph.SelectedNodes[ 0 ] ) + continue; + + OutputPort outputPort = outNode.GetOutputPortByUniqueId( wireRefs[ i ].OutPortId ); + InputPort inputPort = inNode.GetInputPortByUniqueId( wireRefs[ i ].InPortId ); + + // Calculate the 4 points for bezier taking into account wire nodes and their automatic tangents + Vector3 endPos = new Vector3( inputPort.Position.x, inputPort.Position.y ); + Vector3 startPos = new Vector3( outputPort.Position.x, outputPort.Position.y ); + + float mag = ( endPos - startPos ).magnitude; + float resizedMag = Mathf.Min( mag, Constants.HORIZONTAL_TANGENT_SIZE * m_drawInfo.InvertedZoom ); + + Vector3 startTangent = new Vector3( startPos.x + resizedMag, startPos.y ); + Vector3 endTangent = new Vector3( endPos.x - resizedMag, endPos.y ); + + if( inNode != null && inNode.GetType() == typeof( WireNode ) ) + endTangent = endPos + ( ( inNode as WireNode ).TangentDirection ) * mag * 0.33f; + + if( outNode != null && outNode.GetType() == typeof( WireNode ) ) + startTangent = startPos - ( ( outNode as WireNode ).TangentDirection ) * mag * 0.33f; + + //Vector2 pos = ( CurrentGraph.SelectedNodes[0].CenterPosition + m_cameraOffset ) / m_cameraZoom; + + float dist = HandleUtility.DistancePointBezier( /*pos*/ m_currentMousePos, startPos, endPos, startTangent, endTangent ); + if( dist < 40 ) + { + if( dist < closestDist ) + { + closestDist = dist; + closestId = i; + } + } + } + + if( closestDist < 40 ) + { + ParentNode outNode = m_mainGraphInstance.GetNode( wireRefs[ closestId ].OutNodeId ); + ParentNode inNode = m_mainGraphInstance.GetNode( wireRefs[ closestId ].InNodeId ); + + OutputPort outputPort = outNode.GetOutputPortByUniqueId( wireRefs[ closestId ].OutPortId ); + InputPort inputPort = inNode.GetInputPortByUniqueId( wireRefs[ closestId ].InPortId ); + + ParentNode selectedNode = CurrentGraph.SelectedNodes[ 0 ]; + if( selectedNode.InputPorts.Count > 0 && selectedNode.OutputPorts.Count > 0 ) + { + Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateConnectionId ); + selectedNode.RecordObject( Constants.UndoCreateConnectionId ); + inNode.RecordObject( Constants.UndoCreateConnectionId ); + outNode.RecordObject( Constants.UndoCreateConnectionId ); + + m_mainGraphInstance.CreateConnection( selectedNode.UniqueId, selectedNode.InputPorts[ 0 ].PortId, outputPort.NodeId, outputPort.PortId ); + m_mainGraphInstance.CreateConnection( inputPort.NodeId, inputPort.PortId, selectedNode.UniqueId, selectedNode.OutputPorts[ 0 ].PortId ); + } + + SetSaveIsDirty(); + ForceRepaint(); + } + } + } + UIUtils.ShowContextOnPick = true; + m_altBoxSelection = false; + m_multipleSelectionActive = false; + UseCurrentEvent(); + } + + public void ConnectInputToOutput( int inNodeId, int inPortId, int outNodeId, int outPortId, bool registerUndo = true ) + { + ParentNode inNode = m_mainGraphInstance.GetNode( inNodeId ); + ParentNode outNode = m_mainGraphInstance.GetNode( outNodeId ); + if( inNode != null && outNode != null ) + { + InputPort inPort = inNode.GetInputPortByUniqueId( inPortId ); + OutputPort outPort = outNode.GetOutputPortByUniqueId( outPortId ); + if( inPort != null && outPort != null ) + { + if( registerUndo ) + { + Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateConnectionId ); + inNode.RecordObject( Constants.UndoCreateConnectionId ); + outNode.RecordObject( Constants.UndoCreateConnectionId ); + } + + if( inPort.ConnectTo( outNodeId, outPortId, outPort.DataType, inPort.TypeLocked ) ) + { + inNode.OnInputPortConnected( inPortId, outNodeId, outPortId ); + } + + if( outPort.ConnectTo( inNodeId, inPortId, inPort.DataType, inPort.TypeLocked ) ) + { + outNode.OnOutputPortConnected( outPortId, inNodeId, inPortId ); + } + } + m_mainGraphInstance.MarkWireHighlights(); + ShaderIsModified = true; + } + } + + void OnRightMouseDown() + { + Focus(); + m_rmbStartPos = m_currentMousePos2D; + UseCurrentEvent(); + } + + void OnRightMouseDrag() + { + // We look at the control to detect when user hits a tooltip ( which has a hot control of 0 ) + // This needs to be checked because on this first "frame" of hitting a tooltip because it generates incorrect mouse delta values + if( GUIUtility.hotControl == 0 && m_lastHotControl != 0 ) + { + m_lastHotControl = GUIUtility.hotControl; + return; + } + + m_lastHotControl = GUIUtility.hotControl; + if( m_currentEvent.alt ) + { + ModifyZoom( Constants.ALT_CAMERA_ZOOM_SPEED * ( m_currentEvent.delta.x + m_currentEvent.delta.y ), m_altKeyStartPos ); + } + else + { + m_cameraOffset += m_cameraZoom * m_currentEvent.delta; + } + UseCurrentEvent(); + } + + void OnRightMouseUp() + { + //Resetting the hot control test variable so it can be used again on right mouse drag detection ( if we did not do this then m_lastHotControl could be left with a a value of 0 and wouldn't be able to be correctly used on rthe drag ) + m_lastHotControl = -1; + + if( ( m_rmbStartPos - m_currentMousePos2D ).sqrMagnitude < Constants.RMB_SCREEN_DIST ) + { + ParentNode node = m_mainGraphInstance.CheckNodeAt( m_currentMousePos, true ); + if( node == null ) + { + m_contextPalette.Show( m_currentMousePos2D, m_cameraInfo ); + } + } + UseCurrentEvent(); + } + + void UpdateSelectionArea() + { + m_multipleSelectionArea.size = TranformedMousePos - m_multipleSelectionStart; + } + + public void OnValidObjectsDropped( UnityEngine.Object[] droppedObjs ) + { + bool propagateDraggedObjsToNode = true; + // Only supporting single drag&drop object selection + if( droppedObjs.Length == 1 ) + { + ShaderIsModified = true; + SetSaveIsDirty(); + // Check if its a shader, material or game object and if so load the shader graph code from it + Shader newShader = droppedObjs[ 0 ] as Shader; + Material newMaterial = null; + if( newShader == null ) + { + newMaterial = droppedObjs[ 0 ] as Material; +#if UNITY_2018_1_OR_NEWER + bool isProcedural = ( newMaterial != null ); +#else + // Disabling Substance Deprecated warning +#pragma warning disable 0618 + bool isProcedural = ( newMaterial != null && newMaterial is ProceduralMaterial ); +#pragma warning restore 0618 +#endif + if( newMaterial != null && !isProcedural ) + { + if( UIUtils.IsUnityNativeShader( AssetDatabase.GetAssetPath( newMaterial.shader ) ) ) + { + return; + } + //newShader = newMaterial.shader; + LoadMaterialToASE( newMaterial ); + //m_mainGraphInstance.UpdateMaterialOnMasterNode( newMaterial ); + } + else + { + GameObject go = droppedObjs[ 0 ] as GameObject; + if( go != null ) + { + Renderer renderer = go.GetComponent<Renderer>(); + if( renderer ) + { + newMaterial = renderer.sharedMaterial; + newShader = newMaterial.shader; + } + } + } + } + + if( newShader != null ) + { + ConvertShaderToASE( newShader ); + + propagateDraggedObjsToNode = false; + } + + // if not shader loading then propagate the seletion to whats below the mouse + if( propagateDraggedObjsToNode ) + { + ParentNode node = m_mainGraphInstance.CheckNodeAt( m_currentMousePos ); + if( node != null ) + { + // if there's a node then pass the object into it to see if there's a setup with it + node.OnObjectDropped( droppedObjs[ 0 ] ); + } + else + { + // If not then check if there's a node that can be created through the dropped object + ParentNode newNode = m_contextMenu.CreateNodeFromCastType( droppedObjs[ 0 ].GetType() ); + if( newNode ) + { + newNode.ContainerGraph = m_mainGraphInstance; + newNode.Vec2Position = TranformedMousePos; + m_mainGraphInstance.AddNode( newNode, true ); + newNode.SetupFromCastObject( droppedObjs[ 0 ] ); + m_mainGraphInstance.SelectNode( newNode, false, false ); + ForceRepaint(); + bool find = false; + if( newNode is FunctionNode && CurrentGraph.CurrentShaderFunction != null ) + find = SearchFunctionNodeRecursively( CurrentGraph.CurrentShaderFunction ); + + if( find ) + { + DestroyNode( newNode, false ); + ShowMessage( "Shader Function loop detected, new node was removed to prevent errors." ); + } + } + } + } + } + } + + public bool SearchFunctionNodeRecursively( AmplifyShaderFunction function ) + { + List<FunctionNode> graphList = UIUtils.FunctionList(); + + bool nodeFind = false; + + for( int i = 0; i < graphList.Count; i++ ) + { + ParentGraph temp = CustomGraph; + CustomGraph = graphList[ i ].FunctionGraph; + nodeFind = SearchFunctionNodeRecursively( function ); + CustomGraph = temp; + + //Debug.Log( "tested = " + node.Function.FunctionName + " : " + function.FunctionName ); + + if( graphList[ i ].Function == function ) + return true; + } + + return nodeFind; + } + + public void SetDelayedMaterialMode( Material material ) + { + if( material == null ) + return; + m_delayedMaterialSet = material; + } + + public ShaderLoadResult LoadDroppedObject( bool value, Shader shader, Material material, AmplifyShaderFunction shaderFunction = null ) + { + UIUtils.CurrentWindow = this; + ShaderLoadResult result; + if( shaderFunction != null ) + { + string assetDatapath = AssetDatabase.GetAssetPath( shaderFunction ); + string latestOpenedFolder = Application.dataPath + assetDatapath.Substring( 6 ); + UIUtils.LatestOpenedFolder = latestOpenedFolder.Substring( 0, latestOpenedFolder.LastIndexOf( '/' ) + 1 ); + result = LoadFromDisk( assetDatapath, shaderFunction ); + CurrentSelection = ASESelectionMode.ShaderFunction; + IsShaderFunctionWindow = true; + titleContent.text = GenerateTabTitle( shaderFunction.FunctionName ); + titleContent.image = UIUtils.ShaderFunctionIcon; + m_lastpath = assetDatapath; + m_nodeParametersWindow.OnShaderFunctionLoad(); + //EditorPrefs.SetString( IOUtils.LAST_OPENED_OBJ_ID, assetDatapath ); + } + else if( value && shader != null ) + { + string assetDatapath = AssetDatabase.GetAssetPath( shader ); + string latestOpenedFolder = Application.dataPath + assetDatapath.Substring( 6 ); + UIUtils.LatestOpenedFolder = latestOpenedFolder.Substring( 0, latestOpenedFolder.LastIndexOf( '/' ) + 1 ); + result = LoadFromDisk( assetDatapath ); + switch( result ) + { + case ShaderLoadResult.LOADED: + { + m_mainGraphInstance.UpdateShaderOnMasterNode( shader ); + } + break; + case ShaderLoadResult.ASE_INFO_NOT_FOUND: + { + ShowMessage( "Loaded shader wasn't created with ASE. Saving it will remove previous data." ); + UIUtils.CreateEmptyFromInvalid( shader ); + } + break; + case ShaderLoadResult.FILE_NOT_FOUND: + case ShaderLoadResult.UNITY_NATIVE_PATHS: + { + UIUtils.CreateEmptyFromInvalid( shader ); + } + break; + } + + m_mainGraphInstance.UpdateMaterialOnMasterNode( material ); + m_mainGraphInstance.SetMaterialModeOnGraph( material ); + + if( material != null ) + { + CurrentSelection = ASESelectionMode.Material; + IsShaderFunctionWindow = false; + titleContent.text = GenerateTabTitle( material.name ); + titleContent.image = UIUtils.MaterialIcon; + if( material.HasProperty( IOUtils.DefaultASEDirtyCheckId ) ) + { + material.SetInt( IOUtils.DefaultASEDirtyCheckId, 1 ); + } + m_lastpath = AssetDatabase.GetAssetPath( material ); + EditorPrefs.SetString( IOUtils.LAST_OPENED_OBJ_ID, m_lastpath ); + } + else + { + CurrentSelection = ASESelectionMode.Shader; + IsShaderFunctionWindow = false; + titleContent.text = GenerateTabTitle( shader.name ); + titleContent.image = UIUtils.ShaderIcon; + m_lastpath = AssetDatabase.GetAssetPath( shader ); + EditorPrefs.SetString( IOUtils.LAST_OPENED_OBJ_ID, m_lastpath ); + } + } + else + { + result = ShaderLoadResult.FILE_NOT_FOUND; + } + return result; + } + + bool InsideMenus( Vector2 position ) + { + for( int i = 0; i < m_registeredMenus.Count; i++ ) + { + if( m_registeredMenus[ i ].IsInside( position ) ) + { + return true; + } + } + return false; + } + + void HandleGUIEvents() + { + if( m_currentEvent.type == EventType.KeyDown ) + { + m_contextMenu.UpdateKeyPress( m_currentEvent.keyCode ); + } + else if( m_currentEvent.type == EventType.KeyUp ) + { + m_contextMenu.UpdateKeyReleased( m_currentEvent.keyCode ); + } + + if( InsideMenus( m_currentMousePos2D ) ) + { + if( m_currentEvent.type == EventType.Used ) + m_mouseDownOnValidArea = false; + + if( m_currentEvent.type == EventType.MouseDown ) + { + m_mouseDownOnValidArea = false; + UseCurrentEvent(); + } + return; + } + else if( m_nodeParametersWindow.IsResizing || m_paletteWindow.IsResizing ) + { + m_mouseDownOnValidArea = false; + } + + int controlID = GUIUtility.GetControlID( FocusType.Passive ); + switch( m_currentEvent.GetTypeForControl( controlID ) ) + { + case EventType.MouseDown: + { + GUIUtility.hotControl = controlID; + switch( m_currentEvent.button ) + { + case ButtonClickId.LeftMouseButton: + { + OnLeftMouseDown(); + } + break; + case ButtonClickId.RightMouseButton: + case ButtonClickId.MiddleMouseButton: + { + OnRightMouseDown(); + } + break; + } + } + break; + case EventType.MouseMove: + { + m_keyEvtMousePos2D = m_currentEvent.mousePosition; + } + break; + case EventType.MouseUp: + { + GUIUtility.hotControl = 0; + switch( m_currentEvent.button ) + { + case ButtonClickId.LeftMouseButton: + { + OnLeftMouseUp(); + } + break; + case ButtonClickId.MiddleMouseButton: break; + case ButtonClickId.RightMouseButton: + { + OnRightMouseUp(); + } + break; + } + } + break; + case EventType.MouseDrag: + { + switch( m_currentEvent.button ) + { + case ButtonClickId.LeftMouseButton: + { + OnLeftMouseDrag(); + } + break; + case ButtonClickId.MiddleMouseButton: + case ButtonClickId.RightMouseButton: + { + OnRightMouseDrag(); + } + break; + } + } + break; + case EventType.ScrollWheel: + { + OnScrollWheel(); + } + break; + case EventType.KeyDown: + { + OnKeyboardDown(); + } + break; + case EventType.KeyUp: + { + OnKeyboardUp(); + } + break; + case EventType.ValidateCommand: + { + switch( m_currentEvent.commandName ) + { + case CopyCommand: + case PasteCommand: + case SelectAll: + case Duplicate: + { + m_currentEvent.Use(); + } + break; + case ObjectSelectorClosed: + { + m_mouseDownOnValidArea = false; + } + break; + } + } + break; + case EventType.ExecuteCommand: + { + m_currentEvent.Use(); + switch( m_currentEvent.commandName ) + { + case CopyCommand: + { + CopyToClipboard(); + } + break; + case PasteCommand: + { + PasteFromClipboard( true ); + } + break; + case SelectAll: + { + m_mainGraphInstance.SelectAll(); + ForceRepaint(); + } + break; + case Duplicate: + { + CopyToClipboard(); + PasteFromClipboard( true ); + } + break; + case ObjectSelectorClosed: + { + m_mouseDownOnValidArea = false; + } + break; + } + } + break; + case EventType.Repaint: + { + } + break; + } + + m_dragAndDropTool.TestDragAndDrop( m_graphArea ); + + } + + public void DeleteConnection( bool isInput, int nodeId, int portId, bool registerOnLog, bool propagateCallback ) + { + m_mainGraphInstance.DeleteConnection( isInput, nodeId, portId, registerOnLog, propagateCallback ); + } + + void DeleteSelectedNodes() + { + if( m_mainGraphInstance.SelectedNodes.Count == 0 ) + return; + + UIUtils.ClearUndoHelper(); + ParentNode[] selectedNodes = new ParentNode[ m_mainGraphInstance.SelectedNodes.Count ]; + for( int i = 0; i < selectedNodes.Length; i++ ) + { + selectedNodes[ i ] = m_mainGraphInstance.SelectedNodes[ i ]; + selectedNodes[ i ].Rewire(); + UIUtils.CheckUndoNode( selectedNodes[ i ] ); + } + + //Check nodes connected to deleted nodes to preserve connections on undo + List<ParentNode> extraNodes = new List<ParentNode>(); + for( int selectedNodeIdx = 0; selectedNodeIdx < selectedNodes.Length; selectedNodeIdx++ ) + { + // Check inputs + { + int inputIdxCount = selectedNodes[ selectedNodeIdx ].InputPorts.Count; + if( inputIdxCount > 0 ) + { + for( int inputIdx = 0; inputIdx < inputIdxCount; inputIdx++ ) + { + if( selectedNodes[ selectedNodeIdx ].InputPorts[ inputIdx ].IsConnected ) + { + int nodeIdx = selectedNodes[ selectedNodeIdx ].InputPorts[ inputIdx ].ExternalReferences[ 0 ].NodeId; + if( nodeIdx > -1 ) + { + ParentNode node = m_mainGraphInstance.GetNode( nodeIdx ); + if( node != null && UIUtils.CheckUndoNode( node ) ) + { + extraNodes.Add( node ); + } + } + } + } + } + } + + // Check outputs + int outputIdxCount = selectedNodes[ selectedNodeIdx ].OutputPorts.Count; + if( outputIdxCount > 0 ) + { + for( int outputIdx = 0; outputIdx < outputIdxCount; outputIdx++ ) + { + int inputIdxCount = selectedNodes[ selectedNodeIdx ].OutputPorts[ outputIdx ].ExternalReferences.Count; + if( inputIdxCount > 0 ) + { + for( int inputIdx = 0; inputIdx < inputIdxCount; inputIdx++ ) + { + int nodeIdx = selectedNodes[ selectedNodeIdx ].OutputPorts[ outputIdx ].ExternalReferences[ inputIdx ].NodeId; + if( nodeIdx > -1 ) + { + ParentNode node = m_mainGraphInstance.GetNode( nodeIdx ); + if( UIUtils.CheckUndoNode( node ) ) + { + extraNodes.Add( node ); + } + } + } + } + } + } + } + + UIUtils.ClearUndoHelper(); + //Undo.IncrementCurrentGroup(); + //Record deleted nodes + UIUtils.MarkUndoAction(); + Undo.RegisterCompleteObjectUndo( this, Constants.UndoDeleteNodeId ); + Undo.RegisterCompleteObjectUndo( m_mainGraphInstance, Constants.UndoDeleteNodeId ); + Undo.RecordObjects( selectedNodes, Constants.UndoDeleteNodeId ); + Undo.RecordObjects( extraNodes.ToArray(), Constants.UndoDeleteNodeId ); + + //Record deleting connections + for( int i = 0; i < selectedNodes.Length; i++ ) + { + selectedNodes[ i ].Alive = false; + m_mainGraphInstance.DeleteAllConnectionFromNode( selectedNodes[ i ], false, true, true ); + } + //Delete + m_mainGraphInstance.DeleteNodesOnArray( ref selectedNodes ); + + + //Undo.IncrementCurrentGroup(); + extraNodes.Clear(); + extraNodes = null; + + EditorUtility.SetDirty( this ); + + ForceRepaint(); + } + + void OnKeyboardUp() + { + CheckKeyboardCameraUp(); + + if( m_altPressDown ) + { + m_altPressDown = false; + } + + if( m_shortcutManager.ActivateShortcut( m_currentEvent.modifiers, m_lastKeyPressed, false ) ) + { + ForceRepaint(); + } + m_lastKeyPressed = KeyCode.None; + } + + bool OnKeyboardPress( KeyCode code ) + { + return ( m_currentEvent.keyCode == code && m_lastKeyPressed == KeyCode.None ); + } + + void CheckKeyboardCameraDown() + { + if( m_contextPalette.IsActive ) + return; + if( m_currentEvent.alt ) + { + bool foundKey = false; + float dir = 0; + switch( m_currentEvent.keyCode ) + { + case KeyCode.UpArrow: foundKey = true; dir = 1; break; + case KeyCode.DownArrow: foundKey = true; dir = -1; break; + case KeyCode.LeftArrow: foundKey = true; dir = 1; break; + case KeyCode.RightArrow: foundKey = true; dir = -1; break; + } + if( foundKey ) + { + ModifyZoom( Constants.ALT_CAMERA_ZOOM_SPEED * dir * m_cameraSpeed, new Vector2( m_cameraInfo.width * 0.5f, m_cameraInfo.height * 0.5f ) ); + if( m_cameraSpeed < 15 ) + m_cameraSpeed += 0.2f; + UseCurrentEvent(); + } + + + } + else + { + bool foundKey = false; + Vector2 dir = Vector2.zero; + switch( m_currentEvent.keyCode ) + { + case KeyCode.UpArrow: foundKey = true; dir = Vector2.up; break; + case KeyCode.DownArrow: foundKey = true; dir = Vector2.down; break; + case KeyCode.LeftArrow: foundKey = true; dir = Vector2.right; break; + case KeyCode.RightArrow: foundKey = true; dir = Vector2.left; break; + } + if( foundKey ) + { + m_cameraOffset += m_cameraZoom * m_cameraSpeed * dir; + if( m_cameraSpeed < 15 ) + m_cameraSpeed += 0.2f; + + UseCurrentEvent(); + } + } + } + + void CheckKeyboardCameraUp() + { + switch( m_currentEvent.keyCode ) + { + case KeyCode.UpArrow: + case KeyCode.DownArrow: + case KeyCode.LeftArrow: + case KeyCode.RightArrow: m_cameraSpeed = 1; break; + } + } + + void OnKeyboardDown() + { + //if( DebugConsoleWindow.DeveloperMode ) + //{ + // if( OnKeyboardPress( KeyCode.F8 ) ) + // { + // Shader currShader = CurrentGraph.CurrentShader; + // ShaderUtilEx.OpenCompiledShader( currShader, ShaderInspectorPlatformsPopupEx.GetCurrentMode(), ShaderInspectorPlatformsPopupEx.GetCurrentPlatformMask(), ShaderInspectorPlatformsPopupEx.GetCurrentVariantStripping() == 0 ); + + // string filename = Application.dataPath; + // filename = filename.Replace( "Assets", "Temp/Compiled-" ); + // string shaderFilename = AssetDatabase.GetAssetPath( currShader ); + // int lastIndex = shaderFilename.LastIndexOf( '/' ) + 1; + // filename = filename + shaderFilename.Substring( lastIndex ); + + // string compiledContents = IOUtils.LoadTextFileFromDisk( filename ); + // Debug.Log( compiledContents ); + // } + + // if( OnKeyboardPress( KeyCode.F9 ) ) + // { + // m_nodeExporterUtils.CalculateShaderInstructions( CurrentGraph.CurrentShader ); + // } + //} + + CheckKeyboardCameraDown(); + + if( m_lastKeyPressed == KeyCode.None ) + { + m_shortcutManager.ActivateShortcut( m_currentEvent.modifiers, m_currentEvent.keyCode, true ); + } + + if( m_currentEvent.control && m_currentEvent.shift && m_currentEvent.keyCode == KeyCode.V ) + { + PasteFromClipboard( false ); + } + + if( !m_altPressDown && ( OnKeyboardPress( KeyCode.LeftAlt ) || OnKeyboardPress( KeyCode.RightAlt ) || OnKeyboardPress( KeyCode.AltGr ) ) ) + { + m_altPressDown = true; + m_altAvailable = true; + m_altKeyStartPos = m_currentMousePos2D; + } + + if( m_currentEvent.keyCode != KeyCode.None && m_currentEvent.modifiers == EventModifiers.None ) + { + m_lastKeyPressed = m_currentEvent.keyCode; + } + } + + IEnumerator m_coroutine; + + private void StartPasteRequest() + { + m_coroutine = SendPostCoroutine( "http://paste.amplify.pt/api/create" ); + EditorApplication.update += PasteRequest; + } + + IEnumerator SendPostCoroutine( string url ) + { + WWWForm form = new WWWForm(); + form.AddField( "text", Clipboard.ClipboardId + ";" + EditorPrefs.GetString( Clipboard.ClipboardId, string.Empty ) ); + form.AddField( "title", "ASE Copy" ); + form.AddField( "name", "ASE" ); + form.AddField( "private", "1" ); + form.AddField( "lang", "text" ); + form.AddField( "expire", "0" ); + + UnityWebRequest www = UnityWebRequest.Post( url, form ); +#if UNITY_2017_2_OR_NEWER + www.SendWebRequest(); +#else + www.Send(); +#endif + + yield return www; + } + + public void PasteRequest() + { + UnityWebRequest www = (UnityWebRequest)m_coroutine.Current; + if( !m_coroutine.MoveNext() ) + { + if( !www.isDone ) + { + m_coroutine.MoveNext(); + } + else + { +#if UNITY_2020_1_OR_NEWER + if( www.result == UnityWebRequest.Result.ConnectionError ) +#elif UNITY_2017_2_OR_NEWER + if( www.isNetworkError ) +#else + if( www.isError ) +#endif + { + Debug.Log( "[AmplifyShaderEditor]\n" + www.error ); + } + else + { + // Print Body + string finalURL = www.downloadHandler.text; + + if( finalURL.IndexOf( "paste.amplify.pt/view/" ) > -1 ) + { + System.Text.RegularExpressions.Regex parser = new System.Text.RegularExpressions.Regex( @".*(http:\/\/paste.amplify.pt\/view\/)([0-9a-z]*).*", System.Text.RegularExpressions.RegexOptions.Singleline ); + finalURL = parser.Replace( finalURL, "$1raw/$2" ); + + ShowMessage( "Link copied to clipboard\n"+ finalURL, consoleLog:false ); + Debug.Log( "[AmplifyShaderEditor] Link copied to clipboard\n"+ finalURL+"\n" ); + // Copy Paste to clipboard + EditorGUIUtility.systemCopyBuffer = finalURL; + } + else + { + Debug.Log( "[AmplifyShaderEditor] Failed to generate paste:\n" + finalURL ); + } + } + EditorApplication.update -= PasteRequest; + } + } + } + + void OnScrollWheel() + { + ModifyZoomSmooth( m_currentEvent.delta.y, m_currentMousePos2D ); + UseCurrentEvent(); + } + + void ModifyZoom( float zoomIncrement, Vector2 pivot ) + { + float minCam = Mathf.Min( ( m_cameraInfo.width - ( m_nodeParametersWindow.RealWidth + m_paletteWindow.RealWidth ) ), ( m_cameraInfo.height - ( m_toolsWindow.Height ) ) ); + if( minCam < 1 ) + minCam = 1; + + float dynamicMaxZoom = m_mainGraphInstance.MaxNodeDist / minCam; + + Vector2 canvasPos = TranformPosition( pivot ); + if( zoomIncrement < 0 ) + CameraZoom = Mathf.Max( m_cameraZoom + zoomIncrement * Constants.CAMERA_ZOOM_SPEED, Constants.CAMERA_MIN_ZOOM ); + else if( CameraZoom < Mathf.Max( Constants.CAMERA_MAX_ZOOM, dynamicMaxZoom ) ) + CameraZoom = m_cameraZoom + zoomIncrement * Constants.CAMERA_ZOOM_SPEED;// Mathf.Min( m_cameraZoom + zoomIncrement * Constants.CAMERA_ZOOM_SPEED, Mathf.Max( Constants.CAMERA_MAX_ZOOM, dynamicMaxZoom ) ); + m_cameraOffset.x = pivot.x * m_cameraZoom - canvasPos.x; + m_cameraOffset.y = pivot.y * m_cameraZoom - canvasPos.y; + } + + void ModifyZoomSmooth( float zoomIncrement, Vector2 pivot ) + { + if( m_smoothZoom && Mathf.Sign( m_targetZoomIncrement * zoomIncrement ) >= 0 ) + m_targetZoomIncrement += zoomIncrement; + else + m_targetZoomIncrement = zoomIncrement; + + m_smoothZoom = true; + m_zoomTime = 0; + + float minCam = Mathf.Min( ( m_cameraInfo.width - ( m_nodeParametersWindow.RealWidth + m_paletteWindow.RealWidth ) ), ( m_cameraInfo.height - ( m_toolsWindow.Height ) ) ); + if( minCam < 1 ) + minCam = 1; + + float dynamicMaxZoom = m_mainGraphInstance.MaxNodeDist / minCam; + if( m_targetZoomIncrement < 0 ) + m_targetZoom = Mathf.Max( m_cameraZoom + m_targetZoomIncrement * Constants.CAMERA_ZOOM_SPEED, Constants.CAMERA_MIN_ZOOM ); + else if( CameraZoom < Mathf.Max( Constants.CAMERA_MAX_ZOOM, dynamicMaxZoom ) ) + m_targetZoom = m_cameraZoom + m_targetZoomIncrement * Constants.CAMERA_ZOOM_SPEED;// Mathf.Min( m_cameraZoom + zoomIncrement * Constants.CAMERA_ZOOM_SPEED, Mathf.Max( Constants.CAMERA_MAX_ZOOM, dynamicMaxZoom ) ); + + m_zoomPivot = pivot; + } + + void OnSelectionChange() + { + ForceRepaint(); + } + + private void OnFocus() + { + EditorGUI.FocusTextInControl( null ); +#if UNITY_2019_1_OR_NEWER + m_fixOnFocus = true; +#endif + } + + void OnLostFocus() + { + m_lostFocus = true; + m_multipleSelectionActive = false; + m_wireReferenceUtils.InvalidateReferences(); + if( m_genericMessageUI != null ) + m_genericMessageUI.CleanUpMessageStack(); + m_nodeParametersWindow.OnLostFocus(); + m_paletteWindow.OnLostFocus(); + m_contextMenu.ResetShortcutKeyStates(); + } + + void CopyToClipboard() + { + m_copyPasteDeltaMul = 0; + m_copyPasteDeltaPos = new Vector2( float.MaxValue, float.MaxValue ); + m_clipboard.ClearClipboard(); + m_copyPasteInitialPos = m_mainGraphInstance.SelectedNodesCentroid; + m_clipboard.AddToClipboard( m_mainGraphInstance.SelectedNodes, m_copyPasteInitialPos, m_mainGraphInstance ); + } + + ParentNode CreateNodeFromClipboardData( int clipId ) + { + string[] parameters = m_clipboard.CurrentClipboardStrData[ clipId ].Data.Split( IOUtils.FIELD_SEPARATOR ); + System.Type nodeType = System.Type.GetType( parameters[ IOUtils.NodeTypeId ] ); + NodeAttributes attributes = m_contextMenu.GetNodeAttributesForType( nodeType ); + if( attributes != null && !UIUtils.GetNodeAvailabilityInBitArray( attributes.NodeAvailabilityFlags, m_mainGraphInstance.CurrentCanvasMode ) && !UIUtils.GetNodeAvailabilityInBitArray( attributes.NodeAvailabilityFlags, m_currentNodeAvailability ) ) + return null; + + ParentNode newNode = (ParentNode)ScriptableObject.CreateInstance( nodeType ); + newNode.IsNodeBeingCopied = true; + if( newNode != null ) + { + newNode.ContainerGraph = m_mainGraphInstance; + newNode.ClipboardFullReadFromString( ref parameters ); + m_mainGraphInstance.AddNode( newNode, true, true, true, false ); + newNode.IsNodeBeingCopied = false; + m_clipboard.CurrentClipboardStrData[ clipId ].NewNodeId = newNode.UniqueId; + return newNode; + } + return null; + } + + void CreateConnectionsFromClipboardData( int clipId ) + { + if( String.IsNullOrEmpty( m_clipboard.CurrentClipboardStrData[ clipId ].Connections ) ) + return; + string[] lines = m_clipboard.CurrentClipboardStrData[ clipId ].Connections.Split( IOUtils.LINE_TERMINATOR ); + + for( int lineIdx = 0; lineIdx < lines.Length; lineIdx++ ) + { + string[] parameters = lines[ lineIdx ].Split( IOUtils.FIELD_SEPARATOR ); + + int InNodeId = 0; + int InPortId = 0; + int OutNodeId = 0; + int OutPortId = 0; + + try + { + InNodeId = Convert.ToInt32( parameters[ IOUtils.InNodeId ] ); + InPortId = Convert.ToInt32( parameters[ IOUtils.InPortId ] ); + + OutNodeId = Convert.ToInt32( parameters[ IOUtils.OutNodeId ] ); + OutPortId = Convert.ToInt32( parameters[ IOUtils.OutPortId ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + + + int newInNodeId = m_clipboard.GeNewNodeId( InNodeId ); + int newOutNodeId = m_clipboard.GeNewNodeId( OutNodeId ); + + if( newInNodeId > -1 && newOutNodeId > -1 ) + { + ParentNode inNode = m_mainGraphInstance.GetNode( newInNodeId ); + ParentNode outNode = m_mainGraphInstance.GetNode( newOutNodeId ); + + InputPort inputPort = null; + OutputPort outputPort = null; + + if( inNode != null && outNode != null ) + { + inNode.IsNodeBeingCopied = true; + outNode.IsNodeBeingCopied = true; + inputPort = inNode.GetInputPortByUniqueId( InPortId ); + outputPort = outNode.GetOutputPortByUniqueId( OutPortId ); + if( inputPort != null && outputPort != null ) + { + inputPort.ConnectTo( newOutNodeId, OutPortId, outputPort.DataType, false ); + outputPort.ConnectTo( newInNodeId, InPortId, inputPort.DataType, inputPort.TypeLocked ); + + inNode.OnInputPortConnected( InPortId, newOutNodeId, OutPortId ); + outNode.OnOutputPortConnected( OutPortId, newInNodeId, InPortId ); + } + + inNode.IsNodeBeingCopied = false; + outNode.IsNodeBeingCopied = false; + } + } + } + } + + private void StartGetRequest( string url ) + { + m_coroutine = SendGetCoroutine( url ); + EditorApplication.update += GetRequest; + } + + IEnumerator SendGetCoroutine( string url ) + { + UnityWebRequest www = UnityWebRequest.Get( url ); +#if UNITY_2017_2_OR_NEWER + www.SendWebRequest(); +#else + www.Send(); +#endif + + yield return www; + } + + public void GetRequest() + { + UnityWebRequest www = (UnityWebRequest)m_coroutine.Current; + if( !m_coroutine.MoveNext() ) + { + if( !www.isDone ) + { + m_coroutine.MoveNext(); + } + else + { +#if UNITY_2020_1_OR_NEWER + if( www.result == UnityWebRequest.Result.ConnectionError ) +#elif UNITY_2017_2_OR_NEWER + if( www.isNetworkError ) +#else + if( www.isError ) +#endif + { + Debug.Log( "[AmplifyShaderEditor]\n" + www.error ); + } + else + { + string data = www.downloadHandler.text; + if( data.IndexOf( Clipboard.ClipboardId + ";" ) > -1 ) + { + data = www.downloadHandler.text.Replace( Clipboard.ClipboardId + ";", "" ); + if( data.IndexOf( "<div " ) > -1 ) + { + System.Text.RegularExpressions.Regex parser = new System.Text.RegularExpressions.Regex( @"(.*)<div .*", System.Text.RegularExpressions.RegexOptions.Singleline ); + data = parser.Replace( data, "$1" ); + } + EditorGUIUtility.systemCopyBuffer = string.Empty; + Debug.Log( "[AmplifyShaderEditor] Successfully downloaded snippet!" ); + EditorPrefs.SetString( Clipboard.ClipboardId, data ); + try + { + // send paste event instead to make sure it runs properly + Event e = new Event(); + e.type = EventType.ExecuteCommand; + e.commandName = PasteCommand; + this.SendEvent( e ); + } + catch( Exception ) + { + EditorGUIUtility.systemCopyBuffer = string.Empty; + EditorApplication.update -= GetRequest; + throw; + } + } + else + { + Debug.Log( "[AmplifyShaderEditor] Error downloading, snippet might not exist anymore, clearing clipboard..." ); + EditorGUIUtility.systemCopyBuffer = string.Empty; + } + } + EditorApplication.update -= GetRequest; + } + } + } + + void PasteFromClipboard( bool copyConnections ) + { + string result = EditorGUIUtility.systemCopyBuffer; + if( result.IndexOf( "http://paste.amplify.pt/view/raw/" ) > -1 ) + { + StartGetRequest( result ); + return; + } + + if( result.IndexOf( Clipboard.ClipboardId + ";" ) > -1 ) + { + result = result.Replace( Clipboard.ClipboardId + ";", "" ); + EditorPrefs.SetString( Clipboard.ClipboardId, result ); + } + + m_mainGraphInstance.IsDuplicating = true; + m_copyPasteInitialPos = m_clipboard.GetDataFromEditorPrefs(); + if( m_clipboard.CurrentClipboardStrData.Count == 0 ) + { + return; + } + + Vector2 deltaPos = TranformedKeyEvtMousePos - m_copyPasteInitialPos; + if( ( m_copyPasteDeltaPos - deltaPos ).magnitude > 5.0f ) + { + m_copyPasteDeltaMul = 0; + } + else + { + m_copyPasteDeltaMul += 1; + } + m_copyPasteDeltaPos = deltaPos; + + m_mainGraphInstance.DeSelectAll(); + UIUtils.InhibitMessages = true; + + if( m_clipboard.CurrentClipboardStrData.Count > 0 ) + { + UIUtils.MarkUndoAction(); + Undo.RegisterCompleteObjectUndo( this, Constants.UndoPasteNodeId ); + } + + List<ParentNode> createdNodes = new List<ParentNode>(); + for( int i = 0; i < m_clipboard.CurrentClipboardStrData.Count; i++ ) + { + ParentNode node = CreateNodeFromClipboardData( i ); + if( node != null ) + { + m_clipboard.CurrentClipboardStrData[ i ].NewNodeId = node.UniqueId; + Vector2 pos = node.Vec2Position; + node.Vec2Position = pos + deltaPos + m_copyPasteDeltaMul * Constants.CopyPasteDeltaPos; + //node.RefreshExternalReferences(); + node.AfterDuplication(); + createdNodes.Add( node ); + m_mainGraphInstance.SelectNode( node, true, false ); + } + } + + if( copyConnections ) + { + for( int i = 0; i < m_clipboard.CurrentClipboardStrData.Count; i++ ) + { + CreateConnectionsFromClipboardData( i ); + } + } + + // Refresh external references must always be called after all nodes are created + for( int i = 0; i < createdNodes.Count; i++ ) + { + createdNodes[ i ].RefreshExternalReferences(); + } + createdNodes.Clear(); + createdNodes = null; + //Need to force increment on Undo because if not Undo may incorrectly group consecutive pastes + Undo.IncrementCurrentGroup(); + + UIUtils.InhibitMessages = false; + ShaderIsModified = true; + SetSaveIsDirty(); + ForceRepaint(); + m_mainGraphInstance.IsDuplicating = false; + } + + public string GenerateGraphInfo() + { + string graphInfo = IOUtils.ShaderBodyBegin + '\n'; + string nodesInfo = ""; + string connectionsInfo = ""; + graphInfo += VersionInfo.FullLabel + '\n'; + graphInfo += ( + m_cameraInfo.x.ToString() + IOUtils.FIELD_SEPARATOR + + m_cameraInfo.y.ToString() + IOUtils.FIELD_SEPARATOR + + m_cameraInfo.width.ToString() + IOUtils.FIELD_SEPARATOR + + m_cameraInfo.height.ToString() + IOUtils.FIELD_SEPARATOR + + m_cameraOffset.x.ToString() + IOUtils.FIELD_SEPARATOR + + m_cameraOffset.y.ToString() + IOUtils.FIELD_SEPARATOR + + m_cameraZoom.ToString() + IOUtils.FIELD_SEPARATOR + + m_nodeParametersWindow.IsMaximized + IOUtils.FIELD_SEPARATOR + + m_paletteWindow.IsMaximized + '\n' + ); + m_mainGraphInstance.OrderNodesByGraphDepth(); + m_mainGraphInstance.WriteToString( ref nodesInfo, ref connectionsInfo ); + graphInfo += nodesInfo; + graphInfo += connectionsInfo; + graphInfo += IOUtils.ShaderBodyEnd + '\n'; + + return graphInfo; + } + + // TODO: this need to be fused to the main load function somehow + public static void LoadFromMeta( ref ParentGraph graph, GraphContextMenu contextMenu, string meta ) + { + graph.IsLoading = true; + graph.CleanNodes(); + + int checksumId = meta.IndexOf( IOUtils.CHECKSUM ); + if( checksumId > -1 ) + { + string checkSumStoredValue = meta.Substring( checksumId ); + string trimmedBuffer = meta.Remove( checksumId ); + + string[] typeValuePair = checkSumStoredValue.Split( IOUtils.VALUE_SEPARATOR ); + if( typeValuePair != null && typeValuePair.Length == 2 ) + { + // Check read checksum and compare with the actual shader body to detect external changes + string currentChecksumValue = IOUtils.CreateChecksum( trimmedBuffer ); + if( DebugConsoleWindow.DeveloperMode && !currentChecksumValue.Equals( typeValuePair[ 1 ] ) ) + { + //ShowMessage( "Wrong checksum" ); + } + + trimmedBuffer = trimmedBuffer.Replace( "\r", string.Empty ); + // find node info body + int shaderBodyId = trimmedBuffer.IndexOf( IOUtils.ShaderBodyBegin ); + if( shaderBodyId > -1 ) + { + trimmedBuffer = trimmedBuffer.Substring( shaderBodyId ); + //Find set of instructions + string[] instructions = trimmedBuffer.Split( IOUtils.LINE_TERMINATOR ); + // First line is to be ignored and second line contains version + string[] versionParams = instructions[ 1 ].Split( IOUtils.VALUE_SEPARATOR ); + if( versionParams.Length == 2 ) + { + int version = 0; + try + { + version = Convert.ToInt32( versionParams[ 1 ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + + //if( version > versionInfo.FullNumber ) + //{ + //ShowMessage( "This shader was created on a new ASE version\nPlease install v." + version ); + //} + + if( DebugConsoleWindow.DeveloperMode ) + { + //if( version < versionInfo.FullNumber ) + //{ + //ShowMessage( "This shader was created on a older ASE version\nSaving will update it to the new one." ); + //} + } + + graph.LoadedShaderVersion = version; + } + else + { + //ShowMessage( "Corrupted version" ); + } + + // Dummy values,camera values can only be applied after node loading is complete + Rect dummyCameraInfo = new Rect(); + Vector2 dummyCameraOffset = new Vector2(); + //float dummyCameraZoom = 0; + //bool applyDummy = false; + //bool dummyNodeParametersWindowMaximized = false; + //bool dummyPaletteWindowMaximized = false; + + //Second line contains camera information ( position, size, offset and zoom ) + string[] cameraParams = instructions[ 2 ].Split( IOUtils.FIELD_SEPARATOR ); + if( cameraParams.Length == 9 ) + { + //applyDummy = true; + try + { + dummyCameraInfo.x = Convert.ToSingle( cameraParams[ 0 ] ); + dummyCameraInfo.y = Convert.ToSingle( cameraParams[ 1 ] ); + dummyCameraInfo.width = Convert.ToSingle( cameraParams[ 2 ] ); + dummyCameraInfo.height = Convert.ToSingle( cameraParams[ 3 ] ); + dummyCameraOffset.x = Convert.ToSingle( cameraParams[ 4 ] ); + dummyCameraOffset.y = Convert.ToSingle( cameraParams[ 5 ] ); + + //dummyCameraZoom = Convert.ToSingle( cameraParams[ 6 ] ); + //dummyNodeParametersWindowMaximized = Convert.ToBoolean( cameraParams[ 7 ] ); + //dummyPaletteWindowMaximized = Convert.ToBoolean( cameraParams[ 8 ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + } + else + { + //ShowMessage( "Camera parameters are corrupted" ); + } + + // valid instructions are only between the line after version and the line before the last one ( which contains ShaderBodyEnd ) + for( int instructionIdx = 3; instructionIdx < instructions.Length - 1; instructionIdx++ ) + { + //TODO: After all is working, convert string parameters to ints in order to speed up reading + string[] parameters = instructions[ instructionIdx ].Split( IOUtils.FIELD_SEPARATOR ); + + // All nodes must be created before wiring the connections ... + // Since all nodes on the save op are written before the wires, we can safely create them + // If that order is not maintained the it's because of external editing and its the users responsability + switch( parameters[ 0 ] ) + { + case IOUtils.NodeParam: + { + string typeStr = parameters[ IOUtils.NodeTypeId ]; + //System.Type type = System.Type.GetType( parameters[ IOUtils.NodeTypeId ] ); + System.Type type = System.Type.GetType( IOUtils.NodeTypeReplacer.ContainsKey( typeStr ) ? IOUtils.NodeTypeReplacer[ typeStr ] : typeStr ); + if( type != null ) + { + System.Type oldType = type; + NodeAttributes attribs = contextMenu.GetNodeAttributesForType( type ); + if( attribs == null ) + { + attribs = contextMenu.GetDeprecatedNodeAttributesForType( type ); + if( attribs != null ) + { + if( attribs.Deprecated && attribs.DeprecatedAlternativeType != null ) + { + type = attribs.DeprecatedAlternativeType; + //ShowMessage( string.Format( "Node {0} is deprecated and was replaced by {1} ", attribs.Name, attribs.DeprecatedAlternative ) ); + } + } + } + + ParentNode newNode = (ParentNode)ScriptableObject.CreateInstance( type ); + if( newNode != null ) + { + try + { + newNode.ContainerGraph = graph; + if( oldType != type ) + { + newNode.ParentReadFromString( ref parameters ); + newNode.ReadFromDeprecated( ref parameters, oldType ); + } + else + newNode.ReadFromString( ref parameters ); + + + if( oldType == type ) + { + newNode.ReadInputDataFromString( ref parameters ); + if( UIUtils.CurrentShaderVersion() > 5107 ) + { + newNode.ReadOutputDataFromString( ref parameters ); + } + } + } + catch( Exception e ) + { + Debug.LogException( e, newNode ); + } + graph.AddNode( newNode, false, true, false ); + } + } + else + { + UIUtils.ShowMessage( string.Format( "{0} is not a valid ASE node ", parameters[ IOUtils.NodeTypeId ] ), MessageSeverity.Error ); + } + } + break; + case IOUtils.WireConnectionParam: + { + int InNodeId = 0; + int InPortId = 0; + int OutNodeId = 0; + int OutPortId = 0; + + try + { + InNodeId = Convert.ToInt32( parameters[ IOUtils.InNodeId ] ); + InPortId = Convert.ToInt32( parameters[ IOUtils.InPortId ] ); + OutNodeId = Convert.ToInt32( parameters[ IOUtils.OutNodeId ] ); + OutPortId = Convert.ToInt32( parameters[ IOUtils.OutPortId ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + + ParentNode inNode = graph.GetNode( InNodeId ); + ParentNode outNode = graph.GetNode( OutNodeId ); + + //if ( UIUtils.CurrentShaderVersion() < 5002 ) + //{ + // InPortId = inNode.VersionConvertInputPortId( InPortId ); + // OutPortId = outNode.VersionConvertOutputPortId( OutPortId ); + //} + + InputPort inputPort = null; + OutputPort outputPort = null; + if( inNode != null && outNode != null ) + { + + if( UIUtils.CurrentShaderVersion() < 5002 ) + { + InPortId = inNode.VersionConvertInputPortId( InPortId ); + OutPortId = outNode.VersionConvertOutputPortId( OutPortId ); + + inputPort = inNode.GetInputPortByArrayId( InPortId ); + outputPort = outNode.GetOutputPortByArrayId( OutPortId ); + } + else + { + inputPort = inNode.GetInputPortByUniqueId( InPortId ); + outputPort = outNode.GetOutputPortByUniqueId( OutPortId ); + } + + if( inputPort != null && outputPort != null ) + { + bool inputCompatible = inputPort.CheckValidType( outputPort.DataType ); + bool outputCompatible = outputPort.CheckValidType( inputPort.DataType ); + if( inputCompatible && outputCompatible ) + { + inputPort.ConnectTo( OutNodeId, OutPortId, outputPort.DataType, false ); + outputPort.ConnectTo( InNodeId, InPortId, inputPort.DataType, inputPort.TypeLocked ); + + inNode.OnInputPortConnected( InPortId, OutNodeId, OutPortId, false ); + outNode.OnOutputPortConnected( OutPortId, InNodeId, InPortId ); + } + else if( DebugConsoleWindow.DeveloperMode ) + { + if( !inputCompatible ) + UIUtils.ShowIncompatiblePortMessage( true, inNode, inputPort, outNode, outputPort ); + + if( !outputCompatible ) + UIUtils.ShowIncompatiblePortMessage( true, outNode, outputPort, inNode, inputPort ); + } + } + else if( DebugConsoleWindow.DeveloperMode ) + { + if( inputPort == null ) + { + UIUtils.ShowMessage( "Input Port " + InPortId + " doesn't exist on node " + InNodeId, MessageSeverity.Error ); + } + else + { + UIUtils.ShowMessage( "Output Port " + OutPortId + " doesn't exist on node " + OutNodeId, MessageSeverity.Error ); + } + } + } + else if( DebugConsoleWindow.DeveloperMode ) + { + if( inNode == null ) + { + UIUtils.ShowMessage( "Input node " + InNodeId + " doesn't exist", MessageSeverity.Error ); + } + else + { + UIUtils.ShowMessage( "Output node " + OutNodeId + " doesn't exist", MessageSeverity.Error ); + } + } + } + break; + } + } + } + } + } + + graph.CheckForDuplicates(); + graph.UpdateRegisters(); + graph.RefreshExternalReferences(); + graph.ForceSignalPropagationOnMasterNode(); + graph.LoadedShaderVersion = VersionInfo.FullNumber; + //Reset(); + graph.IsLoading = false; + } + + public ShaderLoadResult LoadFromDisk( string pathname, AmplifyShaderFunction shaderFunction = null ) + { + m_mainGraphInstance.IsLoading = true; + System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; + + FullCleanUndoStack(); + m_performFullUndoRegister = true; + + UIUtils.DirtyMask = false; + if( UIUtils.IsUnityNativeShader( pathname ) ) + { + ShowMessage( "Cannot edit native unity shaders.\nReplacing by a new one." ); + return ShaderLoadResult.UNITY_NATIVE_PATHS; + } + + m_lastOpenedLocation = pathname; + Lastpath = pathname; + + string buffer = string.Empty; + if( shaderFunction == null ) + buffer = IOUtils.LoadTextFileFromDisk( pathname ); + else + buffer = shaderFunction.FunctionInfo; + + if( String.IsNullOrEmpty( buffer ) ) + { + ShowMessage( "Could not open file " + pathname ); + return ShaderLoadResult.FILE_NOT_FOUND; + } + + if( !IOUtils.HasValidShaderBody( ref buffer ) ) + { + return ShaderLoadResult.ASE_INFO_NOT_FOUND; + } + + m_mainGraphInstance.CleanNodes(); + Reset(); + + Shader shader = null; + ShaderLoadResult loadResult = ShaderLoadResult.LOADED; + // Find checksum value on body + int checksumId = buffer.IndexOf( IOUtils.CHECKSUM ); + if( checksumId > -1 ) + { + string checkSumStoredValue = buffer.Substring( checksumId ); + string trimmedBuffer = buffer.Remove( checksumId ); + + string[] typeValuePair = checkSumStoredValue.Split( IOUtils.VALUE_SEPARATOR ); + if( typeValuePair != null && typeValuePair.Length == 2 ) + { + // Check read checksum and compare with the actual shader body to detect external changes + string currentChecksumValue = IOUtils.CreateChecksum( trimmedBuffer ); + if( DebugConsoleWindow.DeveloperMode && !currentChecksumValue.Equals( typeValuePair[ 1 ] ) ) + { + ShowMessage( "Wrong checksum" ); + } + + trimmedBuffer = trimmedBuffer.Replace( "\r", string.Empty ); + // find node info body + int shaderBodyId = trimmedBuffer.IndexOf( IOUtils.ShaderBodyBegin ); + if( shaderBodyId > -1 ) + { + trimmedBuffer = trimmedBuffer.Substring( shaderBodyId ); + //Find set of instructions + string[] instructions = trimmedBuffer.Split( IOUtils.LINE_TERMINATOR ); + // First line is to be ignored and second line contains version + string[] versionParams = instructions[ 1 ].Split( IOUtils.VALUE_SEPARATOR ); + if( versionParams.Length == 2 ) + { + int version = 0; + try + { + version = Convert.ToInt32( versionParams[ 1 ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + + if( version > VersionInfo.FullNumber ) + { + ShowMessage( "This shader was created on a new ASE version\nPlease install v." + version ); + } + + if( DebugConsoleWindow.DeveloperMode ) + { + if( version < VersionInfo.FullNumber ) + { + ShowMessage( "This shader was created on a older ASE version\nSaving will update it to the new one." ); + } + } + + m_mainGraphInstance.LoadedShaderVersion = version; + } + else + { + ShowMessage( "Corrupted version" ); + } + + // Dummy values,camera values can only be applied after node loading is complete + Rect dummyCameraInfo = new Rect(); + Vector2 dummyCameraOffset = new Vector2(); + float dummyCameraZoom = 0; + bool applyDummy = false; + bool dummyNodeParametersWindowMaximized = false; + bool dummyPaletteWindowMaximized = false; + + //Second line contains camera information ( position, size, offset and zoom ) + string[] cameraParams = instructions[ 2 ].Split( IOUtils.FIELD_SEPARATOR ); + if( cameraParams.Length == 9 ) + { + applyDummy = true; + try + { + dummyCameraInfo.x = Convert.ToSingle( cameraParams[ 0 ] ); + dummyCameraInfo.y = Convert.ToSingle( cameraParams[ 1 ] ); + dummyCameraInfo.width = Convert.ToSingle( cameraParams[ 2 ] ); + dummyCameraInfo.height = Convert.ToSingle( cameraParams[ 3 ] ); + dummyCameraOffset.x = Convert.ToSingle( cameraParams[ 4 ] ); + dummyCameraOffset.y = Convert.ToSingle( cameraParams[ 5 ] ); + dummyCameraZoom = Convert.ToSingle( cameraParams[ 6 ] ); + + float centerWidth = ( this.position.width - dummyCameraInfo.width ) * 0.5f * dummyCameraZoom; + float centerHeight = ( this.position.height - dummyCameraInfo.height ) * 0.5f * dummyCameraZoom; + + dummyCameraInfo.x += centerWidth; + dummyCameraOffset.x += centerWidth; + dummyCameraInfo.y += centerHeight; + dummyCameraOffset.y += centerHeight; + dummyNodeParametersWindowMaximized = Convert.ToBoolean( cameraParams[ 7 ] ); + dummyPaletteWindowMaximized = Convert.ToBoolean( cameraParams[ 8 ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + } + else + { + ShowMessage( "Camera parameters are corrupted" ); + } + + // valid instructions are only between the line after version and the line before the last one ( which contains ShaderBodyEnd ) + for( int instructionIdx = 3; instructionIdx < instructions.Length - 1; instructionIdx++ ) + { + //TODO: After all is working, convert string parameters to ints in order to speed up reading + string[] parameters = instructions[ instructionIdx ].Split( IOUtils.FIELD_SEPARATOR ); + + // All nodes must be created before wiring the connections ... + // Since all nodes on the save op are written before the wires, we can safely create them + // If that order is not maintained the it's because of external editing and its the users responsability + switch( parameters[ 0 ] ) + { + case IOUtils.NodeParam: + { + string typeStr = parameters[ IOUtils.NodeTypeId ]; + System.Type type = System.Type.GetType( IOUtils.NodeTypeReplacer.ContainsKey( typeStr ) ? IOUtils.NodeTypeReplacer[ typeStr ] : typeStr ); + if( type != null ) + { + System.Type oldType = type; + NodeAttributes attribs = m_contextMenu.GetNodeAttributesForType( type ); + if( attribs == null ) + { + attribs = m_contextMenu.GetDeprecatedNodeAttributesForType( type ); + if( attribs != null ) + { + if( attribs.Deprecated ) + { + if( attribs.DeprecatedAlternativeType != null ) + { + type = attribs.DeprecatedAlternativeType; + ShowMessage( string.Format( "Node {0} is deprecated and was replaced by {1} ", attribs.Name, attribs.DeprecatedAlternative ) ); + } + else + { + if( string.IsNullOrEmpty( attribs.DeprecatedAlternative ) ) + ShowMessage( string.Format( Constants.DeprecatedNoAlternativeMessageStr, attribs.Name, attribs.DeprecatedAlternative ), MessageSeverity.Normal, false ); + else + ShowMessage( string.Format( Constants.DeprecatedMessageStr, attribs.Name, attribs.DeprecatedAlternative ), MessageSeverity.Normal, false ); + } + } + } + } + + ParentNode newNode = (ParentNode)ScriptableObject.CreateInstance( type ); + if( newNode != null ) + { + try + { + newNode.ContainerGraph = m_mainGraphInstance; + if( oldType != type ) + { + newNode.ParentReadFromString( ref parameters ); + newNode.ReadFromDeprecated( ref parameters, oldType ); + } + else + newNode.ReadFromString( ref parameters ); + + + if( oldType == type ) + { + newNode.ReadInputDataFromString( ref parameters ); + if( UIUtils.CurrentShaderVersion() > 5107 ) + { + newNode.ReadOutputDataFromString( ref parameters ); + } + } + } + catch( Exception e ) + { + Debug.LogException( e, newNode ); + } + m_mainGraphInstance.AddNode( newNode, false, true, false ); + } + } + else + { + ShowMessage( string.Format( "{0} is not a valid ASE node ", parameters[ IOUtils.NodeTypeId ] ), MessageSeverity.Error ); + } + } + break; + case IOUtils.WireConnectionParam: + { + int InNodeId = 0; + int InPortId = 0; + int OutNodeId = 0; + int OutPortId = 0; + + try + { + InNodeId = Convert.ToInt32( parameters[ IOUtils.InNodeId ] ); + InPortId = Convert.ToInt32( parameters[ IOUtils.InPortId ] ); + OutNodeId = Convert.ToInt32( parameters[ IOUtils.OutNodeId ] ); + OutPortId = Convert.ToInt32( parameters[ IOUtils.OutPortId ] ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + + ParentNode inNode = m_mainGraphInstance.GetNode( InNodeId ); + ParentNode outNode = m_mainGraphInstance.GetNode( OutNodeId ); + + //if ( UIUtils.CurrentShaderVersion() < 5002 ) + //{ + // InPortId = inNode.VersionConvertInputPortId( InPortId ); + // OutPortId = outNode.VersionConvertOutputPortId( OutPortId ); + //} + + InputPort inputPort = null; + OutputPort outputPort = null; + if( inNode != null && outNode != null ) + { + + if( UIUtils.CurrentShaderVersion() < 5002 ) + { + InPortId = inNode.VersionConvertInputPortId( InPortId ); + OutPortId = outNode.VersionConvertOutputPortId( OutPortId ); + + inputPort = inNode.GetInputPortByArrayId( InPortId ); + outputPort = outNode.GetOutputPortByArrayId( OutPortId ); + } + else + { + inputPort = inNode.GetInputPortByUniqueId( InPortId ); + outputPort = outNode.GetOutputPortByUniqueId( OutPortId ); + } + + if( inputPort != null && outputPort != null ) + { + bool inputCompatible = inputPort.CheckValidType( outputPort.DataType ); + bool outputCompatible = outputPort.CheckValidType( inputPort.DataType ); + if( inputCompatible && outputCompatible ) + { + inputPort.ConnectTo( OutNodeId, OutPortId, outputPort.DataType, false ); + outputPort.ConnectTo( InNodeId, InPortId, inputPort.DataType, inputPort.TypeLocked ); + + inNode.OnInputPortConnected( InPortId, OutNodeId, OutPortId, false ); + outNode.OnOutputPortConnected( OutPortId, InNodeId, InPortId ); + } + else if( DebugConsoleWindow.DeveloperMode ) + { + if( !inputCompatible ) + UIUtils.ShowIncompatiblePortMessage( true, inNode, inputPort, outNode, outputPort ); + + if( !outputCompatible ) + UIUtils.ShowIncompatiblePortMessage( true, outNode, outputPort, inNode, inputPort ); + } + } + else if( DebugConsoleWindow.DeveloperMode ) + { + if( inputPort == null ) + { + UIUtils.ShowMessage( "Input Port " + InPortId + " doesn't exist on node " + InNodeId, MessageSeverity.Error ); + } + else + { + UIUtils.ShowMessage( "Output Port " + OutPortId + " doesn't exist on node " + OutNodeId, MessageSeverity.Error ); + } + } + } + else if( DebugConsoleWindow.DeveloperMode ) + { + if( inNode == null ) + { + UIUtils.ShowMessage( "Input node " + InNodeId + " doesn't exist", MessageSeverity.Error ); + } + else + { + UIUtils.ShowMessage( "Output node " + OutNodeId + " doesn't exist", MessageSeverity.Error ); + } + } + } + break; + } + } + + if( shaderFunction != null ) + { + m_onLoadDone = 2; + if( applyDummy ) + { + m_cameraInfo = dummyCameraInfo; + m_cameraOffset = dummyCameraOffset; + CameraZoom = dummyCameraZoom; + if( DebugConsoleWindow.UseShaderPanelsInfo ) + { + m_nodeParametersWindowMaximized = m_nodeParametersWindow.IsMaximized = dummyNodeParametersWindowMaximized; + m_paletteWindowMaximized = m_paletteWindow.IsMaximized = dummyPaletteWindowMaximized; + } + } + + } + else + { + shader = AssetDatabase.LoadAssetAtPath<Shader>( pathname ); + if( shader ) + { + + m_onLoadDone = 2; + if( applyDummy ) + { + m_cameraInfo = dummyCameraInfo; + m_cameraOffset = dummyCameraOffset; + CameraZoom = dummyCameraZoom; + if( DebugConsoleWindow.UseShaderPanelsInfo ) + { + m_nodeParametersWindowMaximized = m_nodeParametersWindow.IsMaximized = dummyNodeParametersWindowMaximized; + m_paletteWindowMaximized = m_paletteWindow.IsMaximized = dummyPaletteWindowMaximized; + } + } + } + else + { + ShowMessage( "Could not load shader asset" ); + } + } + } + else + { + ShowMessage( "Graph info not found" ); + } + } + else + { + ShowMessage( "Corrupted checksum" ); + } + } + else + { + ShowMessage( "Checksum not found" ); + } + + //m_mainGraphInstance.LoadedShaderVersion = m_versionInfo.FullNumber; + if( UIUtils.CurrentMasterNode() ) + UIUtils.CurrentMasterNode().ForcePortType(); + + UIUtils.DirtyMask = true; + m_checkInvalidConnections = true; + + m_mainGraphInstance.CheckForDuplicates(); + m_mainGraphInstance.UpdateRegisters(); + m_mainGraphInstance.RefreshExternalReferences(); + m_mainGraphInstance.ForceSignalPropagationOnMasterNode(); + + if( shaderFunction != null ) + { + //if( CurrentGraph.CurrentFunctionOutput == null ) + //{ + // //Fix in case a function output node is not marked as main node + // CurrentGraph.AssignMasterNode( UIUtils.FunctionOutputList()[ 0 ], false ); + //} + shaderFunction.ResetDirectivesOrigin(); + CurrentGraph.CurrentShaderFunction = shaderFunction; + } + else + { + if( shader != null ) + { + m_mainGraphInstance.UpdateShaderOnMasterNode( shader ); + if( m_mainGraphInstance.CurrentCanvasMode == NodeAvailability.TemplateShader ) + { + m_mainGraphInstance.RefreshLinkedMasterNodes( false ); + m_mainGraphInstance.OnRefreshLinkedPortsComplete(); + //m_mainGraphInstance.SetLateOptionsRefresh(); + } + } + } + + + m_mainGraphInstance.LoadedShaderVersion = VersionInfo.FullNumber; + + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + + m_mainGraphInstance.IsLoading = false; + //Remove focus from UI elements so no UI is incorrectly selected from previous loads + //Shader Name textfield was sometimes incorrectly selected + GUI.FocusControl( null ); + return loadResult; + } + + public void FullCleanUndoStack() + { + Undo.ClearUndo( this ); + m_mainGraphInstance.FullCleanUndoStack(); + } + + public void FullRegisterOnUndoStack() + { + Undo.RegisterCompleteObjectUndo( this, Constants.UndoRegisterFullGrapId ); + m_mainGraphInstance.FullRegisterOnUndoStack(); + } + + public void ShowPortInfo() + { + GetWindow<PortLegendInfo>(); + } + + public void ShowShaderLibrary() + { + GetWindow<ShaderLibrary>(); + } + + public void ShowMessage( string message, MessageSeverity severity = MessageSeverity.Normal, bool registerTimestamp = true, bool consoleLog = false ) + { + ShowMessage( -1, message, severity, registerTimestamp, consoleLog ); + } + + public void ShowMessage( int messageOwner, string message, MessageSeverity severity = MessageSeverity.Normal, bool registerTimestamp = true, bool consoleLog = false ) + { + if( UIUtils.InhibitMessages || m_genericMessageUI == null ) + return; + + m_consoleLogWindow.AddMessage( severity, message , messageOwner); + + MarkToRepaint(); + + if( consoleLog ) + { + switch( severity ) + { + case MessageSeverity.Normal: + { + Debug.Log( message ); + } + break; + case MessageSeverity.Warning: + { + Debug.LogWarning( message ); + } + break; + case MessageSeverity.Error: + { + Debug.LogError( message ); + } + break; + } + } + } + + // NOTE: this can probably be removed safely + public void ShowMessageImmediately( string message, MessageSeverity severity = MessageSeverity.Normal, bool consoleLog = true ) + { + if( UIUtils.InhibitMessages ) + return; + + switch( severity ) + { + case MessageSeverity.Normal: + { + m_genericMessageContent.text = message; + if( consoleLog ) + { + Debug.Log( message ); + } + } + break; + case MessageSeverity.Warning: + { + m_genericMessageContent.text = "Warning!\n" + message; + if( consoleLog ) + { + Debug.LogWarning( message ); + } + } + break; + case MessageSeverity.Error: + { + m_genericMessageContent.text = "Error!!!\n" + message; + if( consoleLog ) + { + Debug.LogError( message ); + } + } + break; + } + + try + { + ShowNotification( m_genericMessageContent ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + } + + public bool MouseInteracted = false; + +#if UNITY_2019_1_OR_NEWER + private bool m_fixOnFocus = false; + private bool m_fixFocusRepaint = false; +#endif + void OnGUI() + { +#if UNITY_2019_1_OR_NEWER + // hack fix for mouse selecting text fields when window is opening or window not focused? + if( m_fixFocusRepaint && Event.current.type == EventType.Repaint ) + { + // hack over hack: makes texture fields selectable again when window is not focused + if( ( EditorGUIUtility.editingTextField && EditorGUIUtility.hotControl != 0 ) || + !( EditorGUIUtility.editingTextField && EditorGUIUtility.hotControl == EditorGUIUtility.keyboardControl && EditorGUIUtility.keyboardControl != 0 ) + ) + { + EditorGUI.FocusTextInControl( null ); + GUIUtility.keyboardControl = 0; + } + + m_fixOnFocus = false; + m_fixFocusRepaint = false; + } + + if( m_fixOnFocus && ( Event.current.type == EventType.Used || Event.current.type == EventType.MouseDown ) ) + { + m_fixFocusRepaint = true; + } +#endif + + +#if UNITY_2018_3_OR_NEWER + if( ASEPackageManagerHelper.CheckImporter ) + return; +#endif + +#if UNITY_EDITOR_WIN + if( m_openSavedFolder && Event.current.type == EventType.Repaint ) + { + OpenSavedFolder(); + return; + } +#endif + AmplifyShaderEditorWindow cacheWindow = UIUtils.CurrentWindow; + UIUtils.CurrentWindow = this; + + if( !m_initialized || (object)UIUtils.MainSkin == null || !UIUtils.Initialized ) + { + UIUtils.InitMainSkin(); + Init(); + } + + m_currentEvent = Event.current; + if( m_currentEvent.type == EventType.ExecuteCommand || m_currentEvent.type == EventType.ValidateCommand ) + m_currentCommandName = m_currentEvent.commandName; + else + m_currentCommandName = string.Empty; + + System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; + + MouseInteracted = false; + + if( m_refreshOnUndo ) + { + m_refreshOnUndo = false; + m_mainGraphInstance.RefreshOnUndo(); + } + + if( m_refreshAvailableNodes ) + { + RefreshAvaibleNodes(); + } + + if( m_previousShaderFunction != CurrentGraph.CurrentShaderFunction ) + { + m_nodeParametersWindow.ForceUpdate = true; + m_previousShaderFunction = CurrentGraph.CurrentShaderFunction; + } + + if( m_nodeToFocus != null && m_currentEvent.type == EventType.Layout ) + { + FocusOnNode( m_nodeToFocus, m_zoomToFocus, m_selectNodeToFocus ); + m_nodeToFocus = null; + } + + m_mainGraphInstance.OnDuplicateEventWrapper(); + + m_currentInactiveTime = CalculateInactivityTime(); + + if( m_nodeParametersWindow != null && m_innerEditorVariables.NodeParametersMaximized != m_nodeParametersWindow.IsMaximized ) + m_innerEditorVariables.NodeParametersMaximized = m_nodeParametersWindow.IsMaximized; + if( m_paletteWindow != null && m_innerEditorVariables.NodePaletteMaximized != m_paletteWindow.IsMaximized ) + m_innerEditorVariables.NodePaletteMaximized = m_paletteWindow.IsMaximized; + + if( m_checkInvalidConnections ) + { + m_checkInvalidConnections = false; + m_mainGraphInstance.DeleteInvalidConnections(); + } + + //if ( m_repaintIsDirty ) + //{ + // m_repaintIsDirty = false; + // ForceRepaint(); + //} + + if( m_forcingMaterialUpdateFlag ) + { + Focus(); + if( m_materialsToUpdate.Count > 0 ) + { + float percentage = 100.0f * (float)( UIUtils.TotalExampleMaterials - m_materialsToUpdate.Count ) / (float)UIUtils.TotalExampleMaterials; + if( m_forcingMaterialUpdateOp ) // Read + { + Debug.Log( percentage + "% Recompiling " + m_materialsToUpdate[ 0 ].name ); + LoadDroppedObject( true, m_materialsToUpdate[ 0 ].shader, m_materialsToUpdate[ 0 ] ); + } + else // Write + { + Debug.Log( percentage + "% Saving " + m_materialsToUpdate[ 0 ].name ); + SaveToDisk( false ); + m_materialsToUpdate.RemoveAt( 0 ); + } + m_forcingMaterialUpdateOp = !m_forcingMaterialUpdateOp; + } + else + { + Debug.Log( "100% - All Materials compiled " ); + m_forcingMaterialUpdateFlag = false; + } + } + + + if( m_removedKeyboardFocus ) + { + m_removedKeyboardFocus = false; + GUIUtility.keyboardControl = 0; + } + + + Vector2 pos = m_currentEvent.mousePosition; + pos.x += position.x; + pos.y += position.y; + m_insideEditorWindow = position.Contains( pos ); + + if( m_delayedLoadObject != null && m_mainGraphInstance.CurrentMasterNode != null ) + { + m_mainGraphInstance.SetLateOptionsRefresh(); + LoadObject( m_delayedLoadObject ); + m_delayedLoadObject = null; + } + else if( m_delayedLoadObject != null && m_mainGraphInstance.CurrentOutputNode != null ) + { + m_mainGraphInstance.SetLateOptionsRefresh(); + LoadObject( m_delayedLoadObject ); + m_delayedLoadObject = null; + } + + if( m_delayedMaterialSet != null && m_mainGraphInstance.CurrentMasterNode != null ) + { + m_mainGraphInstance.UpdateMaterialOnMasterNode( m_delayedMaterialSet ); + m_mainGraphInstance.SetMaterialModeOnGraph( m_delayedMaterialSet ); + CurrentSelection = ASESelectionMode.Material; + IsShaderFunctionWindow = false; + m_delayedMaterialSet = null; + } + + Material currentMaterial = m_mainGraphInstance.CurrentMaterial; + if( m_forceUpdateFromMaterialFlag ) + { + Focus(); + m_forceUpdateFromMaterialFlag = false; + if( currentMaterial != null ) + { + m_mainGraphInstance.CopyValuesFromMaterial( currentMaterial ); + m_repaintIsDirty = true; + } + } + + m_repaintCount = 0; + m_cameraInfo = position; + + //if( m_currentEvent.type == EventType.keyDown ) + if( m_currentEvent.type == EventType.Repaint ) + m_keyEvtMousePos2D = m_currentEvent.mousePosition; + + m_currentMousePos2D = m_currentEvent.mousePosition; + m_currentMousePos.x = m_currentMousePos2D.x; + m_currentMousePos.y = m_currentMousePos2D.y; + + m_graphArea.width = m_cameraInfo.width; + m_graphArea.height = m_cameraInfo.height; + + m_autoPanDirActive = m_lmbPressed || m_forceAutoPanDir || m_multipleSelectionActive || m_wireReferenceUtils.ValidReferences(); + + + // Need to use it in order to prevent Mismatched LayoutGroup on ValidateCommand when rendering nodes + //if( Event.current.type == EventType.ValidateCommand ) + //{ + // Event.current.Use(); + //} + + // Nodes Graph background area + //GUILayout.BeginArea( m_graphArea, "Nodes" ); + { + // Camera movement is simulated by grabing the current camera offset, transforming it into texture space and manipulating the tiled texture uv coords + GUI.DrawTextureWithTexCoords( m_graphArea, m_graphBgTexture, + new Rect( ( -m_cameraOffset.x / m_graphBgTexture.width ), + ( m_cameraOffset.y / m_graphBgTexture.height ) - m_cameraZoom * m_cameraInfo.height / m_graphBgTexture.height, + m_cameraZoom * m_cameraInfo.width / m_graphBgTexture.width, + m_cameraZoom * m_cameraInfo.height / m_graphBgTexture.height ) ); + + Color col = GUI.color; + GUI.color = new Color( 1, 1, 1, 0.7f ); + GUI.DrawTexture( m_graphArea, m_graphFgTexture, ScaleMode.StretchToFill, true ); + GUI.color = col; + } + //GUILayout.EndArea(); + + if( DebugConsoleWindow.DeveloperMode && m_currentEvent.type == EventType.Repaint ) + { + GUI.Label( new Rect(Screen.width - 60, 40, 60, 50), m_fpsDisplay ); + } + + bool restoreMouse = false; + if( InsideMenus( m_currentMousePos2D ) /*|| _confirmationWindow.IsActive*/ ) + { + if( Event.current.type == EventType.MouseDown ) + { + restoreMouse = true; + Event.current.type = EventType.Ignore; + } + + // Must guarantee that mouse up ops on menus will reset auto pan if it is set + if( m_currentEvent.type == EventType.MouseUp && m_currentEvent.button == ButtonClickId.LeftMouseButton ) + { + m_lmbPressed = false; + } + + } + // Nodes + //GUILayout.BeginArea( m_graphArea ); + { + m_drawInfo.CameraArea = m_cameraInfo; + m_drawInfo.TransformedCameraArea = m_graphArea; + + m_drawInfo.MousePosition = m_currentMousePos2D; + m_drawInfo.CameraOffset = m_cameraOffset; + m_drawInfo.InvertedZoom = 1 / m_cameraZoom; + m_drawInfo.LeftMouseButtonPressed = m_currentEvent.button == ButtonClickId.LeftMouseButton; + m_drawInfo.CurrentEventType = m_currentEvent.type; + m_drawInfo.ZoomChanged = m_zoomChanged; + + m_drawInfo.TransformedMousePos = m_currentMousePos2D * m_cameraZoom - m_cameraOffset; + + if( m_drawInfo.CurrentEventType == EventType.Repaint ) + UIUtils.UpdateMainSkin( m_drawInfo ); + + // Draw mode indicator + m_modeWindow.Draw( m_graphArea, m_currentMousePos2D, m_mainGraphInstance.CurrentShader, currentMaterial, + 0.5f * ( m_graphArea.width - m_paletteWindow.RealWidth - m_nodeParametersWindow.RealWidth ), + ( m_nodeParametersWindow.IsMaximized ? m_nodeParametersWindow.RealWidth : 0 ), + ( m_paletteWindow.IsMaximized ? m_paletteWindow.RealWidth : 0 )/*, m_openedAssetFromNode*/ ); + + PreTestLeftMouseDown(); + //m_consoleLogWindow.Draw( m_graphArea, m_currentMousePos2D, m_currentEvent.button, false, m_paletteWindow.IsMaximized ? m_paletteWindow.RealWidth : 0 ); + //m_mainGraphInstance.DrawBezierBoundingBox(); + //CheckNodeReplacement(); + + // Main Graph Draw + m_repaintIsDirty = m_mainGraphInstance.Draw( m_drawInfo ) || m_repaintIsDirty; + + m_mainGraphInstance.DrawGrid( m_drawInfo ); + bool hasUnusedConnNodes = m_mainGraphInstance.HasUnConnectedNodes; + m_toolsWindow.SetStateOnButton( ToolButtonType.CleanUnusedNodes, hasUnusedConnNodes ? 1 : 0 ); + + m_zoomChanged = false; + + MasterNode masterNode = m_mainGraphInstance.CurrentMasterNode; + if( masterNode != null ) + { + m_toolsWindow.DrawShaderTitle( m_nodeParametersWindow, m_paletteWindow, AvailableCanvasWidth, m_graphArea.height, masterNode.CroppedShaderName ); + } + else if( m_mainGraphInstance.CurrentOutputNode != null ) + { + string functionName = string.Empty; + + if( m_mainGraphInstance.CurrentShaderFunction != null ) + functionName = m_mainGraphInstance.CurrentShaderFunction.FunctionName; + m_toolsWindow.DrawShaderTitle( m_nodeParametersWindow, m_paletteWindow, AvailableCanvasWidth, m_graphArea.height, functionName ); + } + } + //m_consoleLogWindow.Draw( m_graphArea, m_currentMousePos2D, m_currentEvent.button, false, m_paletteWindow.IsMaximized ? m_paletteWindow.RealWidth : 0 ); + //GUILayout.EndArea(); + + if( restoreMouse ) + { + Event.current.type = EventType.MouseDown; + m_drawInfo.CurrentEventType = EventType.MouseDown; + } + + m_toolsWindow.InitialX = m_nodeParametersWindow.RealWidth; + m_toolsWindow.Width = m_cameraInfo.width - ( m_nodeParametersWindow.RealWidth + m_paletteWindow.RealWidth ); + m_toolsWindow.Draw( m_cameraInfo, m_currentMousePos2D, m_currentEvent.button, false ); + + m_tipsWindow.Draw( m_cameraInfo, m_currentMousePos2D, m_currentEvent.button, false ); + + bool autoMinimize = false; + if( position.width < m_lastWindowWidth && position.width < Constants.MINIMIZE_WINDOW_LOCK_SIZE ) + { + autoMinimize = true; + } + + if( autoMinimize ) + m_nodeParametersWindow.IsMaximized = false; + + ParentNode selectedNode = ( m_mainGraphInstance.SelectedNodes.Count == 1 ) ? m_mainGraphInstance.SelectedNodes[ 0 ] : m_mainGraphInstance.CurrentMasterNode; + m_repaintIsDirty = m_nodeParametersWindow.Draw( m_cameraInfo, selectedNode, m_currentMousePos2D, m_currentEvent.button, false ) || m_repaintIsDirty; //TODO: If multiple nodes from the same type are selected also show a parameters window which modifies all of them + if( m_nodeParametersWindow.IsResizing ) + m_repaintIsDirty = true; + + // Test to ignore mouse on main palette when inside context palette ... IsInside also takes active state into account + bool ignoreMouseForPalette = m_contextPalette.IsInside( m_currentMousePos2D ); + if( ignoreMouseForPalette && Event.current.type == EventType.MouseDown ) + { + Event.current.type = EventType.Ignore; + m_drawInfo.CurrentEventType = EventType.Ignore; + } + if( autoMinimize ) + m_paletteWindow.IsMaximized = false; + + m_paletteWindow.Draw( m_cameraInfo, m_currentMousePos2D, m_currentEvent.button, !m_contextPalette.IsActive ); + if( m_paletteWindow.IsResizing ) + { + m_repaintIsDirty = true; + } + + if( ignoreMouseForPalette ) + { + if( restoreMouse ) + { + Event.current.type = EventType.MouseDown; + m_drawInfo.CurrentEventType = EventType.MouseDown; + } + } + + m_consoleLogWindow.Draw( m_graphArea, m_currentMousePos2D, m_currentEvent.button, false, m_paletteWindow.IsMaximized ? m_paletteWindow.RealWidth : 0 ); + + if( m_contextPalette.IsActive ) + { + m_contextPalette.Draw( m_cameraInfo, m_currentMousePos2D, m_currentEvent.button, m_contextPalette.IsActive ); + } + + if( m_palettePopup.IsActive ) + { + m_palettePopup.Draw( m_currentMousePos2D ); + m_repaintIsDirty = true; + int controlID = GUIUtility.GetControlID( FocusType.Passive ); + if( m_currentEvent.GetTypeForControl( controlID ) == EventType.MouseUp ) + { + if( m_currentEvent.button == ButtonClickId.LeftMouseButton ) + { + m_palettePopup.Deactivate(); + if( !InsideMenus( m_currentMousePos2D ) ) + { + ParentNode newNode = CreateNode( m_paletteChosenType, TranformedMousePos, m_paletteChosenFunction ); + //Debug.Log("created menu"); + m_mainGraphInstance.SelectNode( newNode, false, false ); + + bool find = false; + if( newNode is FunctionNode && CurrentGraph.CurrentShaderFunction != null ) + find = SearchFunctionNodeRecursively( CurrentGraph.CurrentShaderFunction ); + + if( find ) + { + DestroyNode( newNode, false ); + ShowMessage( "Shader Function loop detected, new node was removed to prevent errors." ); + } + else + { + newNode.RefreshExternalReferences(); + } + } + } + } + } + + // Handle all events ( mouse interaction + others ) + if( !MouseInteracted ) + HandleGUIEvents(); + + if( m_currentEvent.type == EventType.Repaint ) + { + m_mainGraphInstance.UpdateMarkForDeletion(); + } + // UI Overlay + // Selection Box + if( m_multipleSelectionActive ) + { + UpdateSelectionArea(); + Rect transformedArea = m_multipleSelectionArea; + transformedArea.position = ( transformedArea.position + m_cameraOffset ) / m_cameraZoom; + transformedArea.size /= m_cameraZoom; + + if( transformedArea.width < 0 ) + { + transformedArea.width = -transformedArea.width; + transformedArea.x -= transformedArea.width; + } + + if( transformedArea.height < 0 ) + { + transformedArea.height = -transformedArea.height; + transformedArea.y -= transformedArea.height; + } + Color original = GUI.color; + GUI.color = Constants.BoxSelectionColor; + GUI.Label( transformedArea, "", UIUtils.Box ); + GUI.color = original; + //GUI.backgroundColor = original; + } + + bool isResizing = m_nodeParametersWindow.IsResizing || m_paletteWindow.IsResizing; + //Test boundaries for auto-pan + if( !isResizing && m_autoPanDirActive ) + { + m_autoPanArea[ (int)AutoPanLocation.LEFT ].AdjustInitialX = m_nodeParametersWindow.IsMaximized ? m_nodeParametersWindow.RealWidth : 0; + m_autoPanArea[ (int)AutoPanLocation.RIGHT ].AdjustInitialX = m_paletteWindow.IsMaximized ? -m_paletteWindow.RealWidth : 0; + Vector2 autoPanDir = Vector2.zero; + for( int i = 0; i < m_autoPanArea.Length; i++ ) + { + if( m_autoPanArea[ i ].CheckArea( m_currentMousePos2D, m_cameraInfo, false ) ) + { + autoPanDir += m_autoPanArea[ i ].Velocity; + } + } + m_cameraOffset += autoPanDir; + if( !m_wireReferenceUtils.ValidReferences() && m_insideEditorWindow && !m_altBoxSelection ) + { + m_mainGraphInstance.MoveSelectedNodes( -autoPanDir ); + } + + m_repaintIsDirty = true; + } + + m_isDirty = m_isDirty || m_mainGraphInstance.IsDirty; + if( m_isDirty ) + { + m_isDirty = false; + //ShaderIsModified = true; + EditorUtility.SetDirty( this ); + } + + m_saveIsDirty = m_saveIsDirty || m_mainGraphInstance.SaveIsDirty; + if( m_liveShaderEditing ) + { + if( m_saveIsDirty ) + { + if( focusedWindow == this && m_currentInactiveTime > InactivitySaveTime ) + { + m_saveIsDirty = false; + if( m_mainGraphInstance.CurrentMasterNodeId != Constants.INVALID_NODE_ID ) + { + SaveToDisk( true ); + } + else + { + ShowMessage( LiveShaderError ); + } + } + } + } + else if( m_saveIsDirty ) + { + ShaderIsModified = true; + m_saveIsDirty = false; + } + + if( m_onLoadDone > 0 ) + { + m_onLoadDone--; + if( m_onLoadDone == 0 ) + { + ShaderIsModified = false; + } + } + + if( m_cacheSaveOp ) + { + if( ( EditorApplication.timeSinceStartup - m_lastTimeSaved ) > SaveTime ) + { + SaveToDisk( false ); + } + } + m_genericMessageUI.CheckForMessages(); + + if( m_ctrlSCallback ) + { + m_ctrlSCallback = false; + OnToolButtonPressed( ToolButtonType.Update ); + } + + m_lastWindowWidth = position.width; + m_nodeExporterUtils.Update(); + + if( m_markedToSave ) + { + m_markedToSave = false; + SaveToDisk( false ); + } + if( m_performFullUndoRegister ) + { + m_performFullUndoRegister = false; + FullRegisterOnUndoStack(); + } + + if( CheckFunctions ) + CheckFunctions = false; + + System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture; + + UIUtils.CurrentWindow = cacheWindow; + if( !m_nodesLoadedCorrectly ) + { + try + { + ShowNotification( NodesExceptionMessage ); + } + catch( Exception e ) + { + Debug.LogException( e ); + } + } + + CheckNodeReplacement(); +#if UNITY_EDITOR_WIN + if( m_takeScreenShot ) + FocusZoom( true, false, false ); + + if( m_takeScreenShot && Event.current.type == EventType.Repaint ) + TakeScreenShot(); +#endif + } + + void OnInspectorUpdate() + { + Preferences.LoadDefaults(); +#if UNITY_2018_3_OR_NEWER + ASEPackageManagerHelper.Update(); +#endif + + if( m_afterDeserializeFlag ) + { + m_afterDeserializeFlag = false; + //m_mainGraphInstance.ParentWindow = this; + } + + if( IsShaderFunctionWindow && CurrentGraph.CurrentShaderFunction == null ) + { + Close(); + } + } + + public void SetCtrlSCallback( bool imediate ) + { + //MasterNode node = _mainGraphInstance.CurrentMasterNode; + if( /*node != null && node.CurrentShader != null && */m_shaderIsModified ) + { + if( imediate ) + { + OnToolButtonPressed( ToolButtonType.Update ); + } + else + { + m_ctrlSCallback = true; + } + } + } + + public void SetSaveIsDirty() + { + m_saveIsDirty = true && UIUtils.DirtyMask; + } + + public void OnPaletteNodeCreate( System.Type type, string name, AmplifyShaderFunction function ) + { + m_mainGraphInstance.DeSelectAll(); + m_paletteChosenType = type; + m_paletteChosenFunction = function; + m_palettePopup.Activate( name ); + } + + public void OnContextPaletteNodeCreate( System.Type type, string name, AmplifyShaderFunction function ) + { + m_mainGraphInstance.DeSelectAll(); + ParentNode newNode = CreateNode( type, m_contextPalette.StartDropPosition * m_cameraZoom - m_cameraOffset, function ); + //Debug.Log( "created context" ); + m_mainGraphInstance.SelectNode( newNode, false, false ); + bool find = false; + if( newNode is FunctionNode && CurrentGraph.CurrentShaderFunction != null ) + find = SearchFunctionNodeRecursively( CurrentGraph.CurrentShaderFunction ); + + if( find ) + { + DestroyNode( newNode, false ); + ShowMessage( "Shader Function loop detected, new node was removed to prevent errors." ); + } + else + { + newNode.RefreshExternalReferences(); + } + } + + void OnNodeStoppedMovingEvent( ParentNode node ) + { + CheckZoomBoundaries( node.Vec2Position ); + //ShaderIsModified = true; + } + + void OnRefreshFunctionNodeEvent( FunctionNode node ) + { + Debug.Log( node ); + } + + void OnMaterialUpdated( MasterNode masterNode ) + { + if( masterNode != null ) + { + if( masterNode.CurrentMaterial ) + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Update, ShaderIsModified ? 0 : 2, ShaderIsModified ? "Click to update Shader preview." : "Preview up-to-date." ); + } + else + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Update, 1, "Set an active Material in the Master Node." ); + } + UpdateLiveUI(); + } + else + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Update, 1, "Set an active Material in the Master Node." ); + } + } + + void OnShaderUpdated( MasterNode masterNode ) + { + m_toolsWindow.SetStateOnButton( ToolButtonType.OpenSourceCode, masterNode.CurrentShader != null ? 1 : 0 ); + } + + public void CheckZoomBoundaries( Vector2 newPosition ) + { + if( newPosition.x < m_minNodePos.x ) + { + m_minNodePos.x = newPosition.x; + } + else if( newPosition.x > m_maxNodePos.x ) + { + m_maxNodePos.x = newPosition.x; + } + + if( newPosition.y < m_minNodePos.y ) + { + m_minNodePos.y = newPosition.y; + } + else if( newPosition.y > m_maxNodePos.y ) + { + m_maxNodePos.y = newPosition.y; + } + } + public void DestroyNode( ParentNode node, bool registerUndo = true ) { m_mainGraphInstance.DestroyNode( node, registerUndo ); } + public ParentNode CreateNode( System.Type type, Vector2 position, AmplifyShaderFunction function = null, bool selectNode = true ) + { + ParentNode node; + if( function == null ) + node = m_mainGraphInstance.CreateNode( type, true ); + else + node = m_mainGraphInstance.CreateNode( function, true ); + + Vector2 newPosition = position; + node.Vec2Position = newPosition; + CheckZoomBoundaries( newPosition ); + + // Connect node if a wire is active + if( m_wireReferenceUtils.ValidReferences() ) + { + if( m_wireReferenceUtils.InputPortReference.IsValid ) + { + ParentNode originNode = m_mainGraphInstance.GetNode( m_wireReferenceUtils.InputPortReference.NodeId ); + InputPort originPort = originNode.GetInputPortByUniqueId( m_wireReferenceUtils.InputPortReference.PortId ); + OutputPort outputPort = node.GetFirstOutputPortOfType( m_wireReferenceUtils.InputPortReference.DataType, true ); + if( outputPort != null && originPort.CheckValidType( outputPort.DataType ) && ( !m_wireReferenceUtils.InputPortReference.TypeLocked || + m_wireReferenceUtils.InputPortReference.DataType == WirePortDataType.OBJECT || + ( m_wireReferenceUtils.InputPortReference.TypeLocked && outputPort.DataType == m_wireReferenceUtils.InputPortReference.DataType ) ) ) + { + + //link output to input + if( outputPort.ConnectTo( m_wireReferenceUtils.InputPortReference.NodeId, m_wireReferenceUtils.InputPortReference.PortId, m_wireReferenceUtils.InputPortReference.DataType, m_wireReferenceUtils.InputPortReference.TypeLocked ) ) + node.OnOutputPortConnected( outputPort.PortId, m_wireReferenceUtils.InputPortReference.NodeId, m_wireReferenceUtils.InputPortReference.PortId ); + + //link input to output + if( originPort.ConnectTo( outputPort.NodeId, outputPort.PortId, outputPort.DataType, m_wireReferenceUtils.InputPortReference.TypeLocked ) ) + originNode.OnInputPortConnected( m_wireReferenceUtils.InputPortReference.PortId, node.UniqueId, outputPort.PortId ); + } + } + + if( m_wireReferenceUtils.OutputPortReference.IsValid ) + { + ParentNode originNode = m_mainGraphInstance.GetNode( m_wireReferenceUtils.OutputPortReference.NodeId ); + InputPort inputPort = node.GetFirstInputPortOfType( m_wireReferenceUtils.OutputPortReference.DataType, true ); + + if( inputPort != null && ( !inputPort.TypeLocked || + inputPort.DataType == WirePortDataType.OBJECT || + ( inputPort.TypeLocked && inputPort.DataType == m_wireReferenceUtils.OutputPortReference.DataType ) ) ) + { + + inputPort.InvalidateAllConnections(); + //link input to output + if( inputPort.ConnectTo( m_wireReferenceUtils.OutputPortReference.NodeId, m_wireReferenceUtils.OutputPortReference.PortId, m_wireReferenceUtils.OutputPortReference.DataType, inputPort.TypeLocked ) ) + node.OnInputPortConnected( inputPort.PortId, m_wireReferenceUtils.OutputPortReference.NodeId, m_wireReferenceUtils.OutputPortReference.PortId ); + //link output to input + + if( originNode.GetOutputPortByUniqueId( m_wireReferenceUtils.OutputPortReference.PortId ).ConnectTo( inputPort.NodeId, inputPort.PortId, m_wireReferenceUtils.OutputPortReference.DataType, inputPort.TypeLocked ) ) + originNode.OnOutputPortConnected( m_wireReferenceUtils.OutputPortReference.PortId, node.UniqueId, inputPort.PortId ); + } + } + m_wireReferenceUtils.InvalidateReferences(); + + //for ( int i = 0; i < m_mainGraphInstance.VisibleNodes.Count; i++ ) + //{ + // m_mainGraphInstance.VisibleNodes[ i ].OnNodeInteraction( node ); + //} + } + + if( selectNode ) + m_mainGraphInstance.SelectNode( node, false, false ); + //_repaintIsDirty = true + + SetSaveIsDirty(); + ForceRepaint(); + return node; + } + + public void UpdateNodePreviewListAndTime() + { + if( UIUtils.CurrentWindow != this ) + return; + + double deltaTime = Time.realtimeSinceStartup - m_time; + m_time = Time.realtimeSinceStartup; + + if( DebugConsoleWindow.DeveloperMode ) + { + m_frameCounter++; + if( m_frameCounter >= 60 ) + { + m_fpsDisplay = ( 60 / ( Time.realtimeSinceStartup - m_fpsTime ) ).ToString( "N2" ); + m_fpsTime = Time.realtimeSinceStartup; + m_frameCounter = 0; + } + } + + if( m_smoothZoom ) + { + m_repaintIsDirty = true; + if( Mathf.Abs( m_targetZoom - m_cameraZoom ) < 0.001f ) + { + m_smoothZoom = false; + m_cameraZoom = m_targetZoom; + m_zoomTime = 0; + } + else + { + m_zoomTime += deltaTime; + Vector2 canvasPos = m_zoomPivot * m_cameraZoom; + m_cameraZoom = Mathf.SmoothDamp( m_cameraZoom, m_targetZoom, ref m_zoomVelocity, 0.1f, 10000, (float)deltaTime * 1.5f ); + canvasPos = canvasPos - m_zoomPivot * m_cameraZoom; + m_cameraOffset = m_cameraOffset - canvasPos; + m_targetOffset = m_targetOffset - canvasPos; + } + + } + + if( m_smoothOffset ) + { + m_repaintIsDirty = true; + if( ( m_targetOffset - m_cameraOffset ).SqrMagnitude() < 1f ) + { + m_smoothOffset = false; + m_offsetTime = 0; + } + else + { + m_offsetTime += deltaTime; + m_cameraOffset = Vector2.SmoothDamp( m_cameraOffset, m_targetOffset, ref m_camVelocity, 0.1f, 100000, (float)deltaTime * 1.5f ); + } + } + + if( m_cachedEditorTimeId == -1 ) + m_cachedEditorTimeId = Shader.PropertyToID( "_EditorTime" ); + + if( m_cachedEditorDeltaTimeId == -1 ) + m_cachedEditorDeltaTimeId = Shader.PropertyToID( "_EditorDeltaTime" ); + + //Update Game View? + //Shader.SetGlobalVector( "_Time", new Vector4( Time.realtimeSinceStartup / 20, Time.realtimeSinceStartup, Time.realtimeSinceStartup * 2, Time.realtimeSinceStartup * 3 ) ); + + //System.Type T = System.Type.GetType( "UnityEditor.GameView,UnityEditor" ); + //UnityEngine.Object[] array = Resources.FindObjectsOfTypeAll( T ); + //EditorWindow gameView = ( array.Length <= 0 ) ? null : ( ( EditorWindow ) array[ 0 ] ); + //gameView.Repaint(); + + if( RenderSettings.sun != null ) + { + Vector3 lightdir = -RenderSettings.sun.transform.forward;//.rotation.eulerAngles; + + Shader.SetGlobalVector( "_EditorWorldLightPos", new Vector4( lightdir.x, lightdir.y, lightdir.z, 0 ) ); + Shader.SetGlobalColor( "_EditorLightColor", RenderSettings.sun.color.linear ); + } + Shader.SetGlobalFloat( "_EditorTime", (float)m_time ); + Shader.SetGlobalFloat( "_EditorDeltaTime", (float)deltaTime ); + + /////////// UPDATE PREVIEWS ////////////// + UIUtils.CheckNullMaterials(); + //CurrentGraph.AllNodes.Sort( ( x, y ) => { return x.Depth.CompareTo( y.Depth ); } ); + int nodeCount = CurrentGraph.AllNodes.Count; + for( int i = nodeCount - 1; i >= 0; i-- ) + { + ParentNode node = CurrentGraph.AllNodes[ i ]; + if( node != null && !VisitedChanged.ContainsKey( node.OutputId ) ) + { + bool result = node.RecursivePreviewUpdate(); + if( result ) + m_repaintIsDirty = true; + } + } + + VisitedChanged.Clear(); + if( m_repaintIsDirty ) + { + m_repaintIsDirty = false; + Repaint(); + } + } + + public void ForceRepaint() + { + m_repaintCount += 1; + m_repaintIsDirty = true; + //Repaint(); + } + + public void ForceUpdateFromMaterial() { m_forceUpdateFromMaterialFlag = true; } + void UseCurrentEvent() + { + m_currentEvent.Use(); + } + + + + public void OnBeforeSerialize() + { + //if ( !UIUtils.SerializeFromUndo() ) + //{ + // m_mainGraphInstance.DeSelectAll(); + //} + + if( DebugConsoleWindow.UseShaderPanelsInfo ) + { + if( m_nodeParametersWindow != null ) + m_nodeParametersWindowMaximized = m_nodeParametersWindow.IsMaximized; + + if( m_paletteWindow != null ) + m_paletteWindowMaximized = m_paletteWindow.IsMaximized; + } + } + + public void OnAfterDeserialize() + { + m_afterDeserializeFlag = true; + + //m_customGraph = null; + if( DebugConsoleWindow.UseShaderPanelsInfo ) + { + if( m_nodeParametersWindow != null ) + m_nodeParametersWindow.IsMaximized = m_nodeParametersWindowMaximized; + + if( m_paletteWindow != null ) + m_paletteWindow.IsMaximized = m_paletteWindowMaximized; + } + } + + void OnDestroy() + { + m_ctrlSCallback = false; + Destroy(); + } + + public override void OnDisable() + { + base.OnDisable(); + m_ctrlSCallback = false; + //EditorApplication.update -= UpdateTime; + EditorApplication.update -= UpdateNodePreviewListAndTime; + + EditorApplication.update -= IOUtils.UpdateIO; + + for( int i = 0; i < IOUtils.AllOpenedWindows.Count; i++ ) + { + if( IOUtils.AllOpenedWindows[ i ] != this ) + { + EditorApplication.update += IOUtils.UpdateIO; + break; + } + } + } + + void OnEmptyGraphDetected( ParentGraph graph ) + { + if( m_delayedLoadObject != null ) + { + LoadObject( m_delayedLoadObject ); + m_delayedLoadObject = null; + Repaint(); + } + else + { + if( !string.IsNullOrEmpty( Lastpath ) ) + { + Shader shader = AssetDatabase.LoadAssetAtPath<Shader>( Lastpath ); + if( shader == null ) + { + Material material = AssetDatabase.LoadAssetAtPath<Material>( Lastpath ); + if( material != null ) + { + LoadDroppedObject( true, material.shader, material, null ); + } + else + { + AmplifyShaderFunction function = AssetDatabase.LoadAssetAtPath<AmplifyShaderFunction>( Lastpath ); + if( function != null ) + { + LoadDroppedObject( true, null, null, function ); + } + } + } + else + { + LoadDroppedObject( true, shader, null, null ); + } + Repaint(); + } + } + } + + + public void ForceMaterialsToUpdate( ref Dictionary<string, string> availableMaterials ) + { + m_forcingMaterialUpdateOp = true; + m_forcingMaterialUpdateFlag = true; + m_materialsToUpdate.Clear(); + foreach( KeyValuePair<string, string> kvp in availableMaterials ) + { + Material material = AssetDatabase.LoadAssetAtPath<Material>( AssetDatabase.GUIDToAssetPath( kvp.Value ) ); + if( material != null ) + { + m_materialsToUpdate.Add( material ); + } + } + } + + public void SetOutdatedShaderFromTemplate() + { + m_outdatedShaderFromTemplateLoaded = true; + } + + public void ReplaceMasterNode( MasterNodeCategoriesData data, bool cacheMasterNodes ) + { + // save connection list before switching + m_savedList.Clear(); + int count = m_mainGraphInstance.CurrentMasterNode.InputPorts.Count; + for( int i = 0; i < count; i++ ) + { + if( m_mainGraphInstance.CurrentMasterNode.InputPorts[ i ].IsConnected ) + { + string name = m_mainGraphInstance.CurrentMasterNode.InputPorts[ i ].Name; + OutputPort op = m_mainGraphInstance.CurrentMasterNode.InputPorts[ i ].GetOutputConnection(); + if( !m_savedList.ContainsKey( name ) ) + { + m_savedList.Add( name, op ); + } + } + } + + m_replaceMasterNodeType = data.Category; + m_replaceMasterNode = true; + m_replaceMasterNodeData = data.Name; + m_replaceMasterNodeDataFromCache = cacheMasterNodes; + if( cacheMasterNodes ) + { + m_clipboard.AddMultiPassNodesToClipboard( m_mainGraphInstance.MultiPassMasterNodes.NodesList ); + } + } + + void CheckNodeReplacement() + { + if( m_replaceMasterNode ) + { + m_replaceMasterNode = false; + switch( m_replaceMasterNodeType ) + { + default: + case AvailableShaderTypes.SurfaceShader: + { + SetStandardShader(); + if( IOUtils.OnShaderTypeChangedEvent != null ) + { + IOUtils.OnShaderTypeChangedEvent( m_mainGraphInstance.CurrentShader, false, string.Empty ); + } + } + break; + case AvailableShaderTypes.Template: + { + + TemplateDataParent templateData = m_templatesManager.GetTemplate( m_replaceMasterNodeData ); + if( m_replaceMasterNodeDataFromCache ) + { + m_mainGraphInstance.CrossCheckTemplateNodes( templateData ); + m_clipboard.GetMultiPassNodesFromClipboard( m_mainGraphInstance.MultiPassMasterNodes.NodesList ); + } + else + { + SetTemplateShader( m_replaceMasterNodeData, false ); + } + + if( IOUtils.OnShaderTypeChangedEvent != null ) + { + IOUtils.OnShaderTypeChangedEvent( m_mainGraphInstance.CurrentShader, true, templateData.GUID ); + } + } + break; + } + } + else if( m_outdatedShaderFromTemplateLoaded ) + { + m_outdatedShaderFromTemplateLoaded = false; + TemplateMultiPassMasterNode masterNode = m_mainGraphInstance.CurrentMasterNode as TemplateMultiPassMasterNode; + if( masterNode != null ) + { + ReplaceMasterNode( masterNode.CurrentCategoriesData, true ); + } + } + + // restore possible connections by name + if( m_savedList.Count > 0 ) + { + foreach( var item in m_savedList ) + { + string name = item.Key; + OutputPort op = item.Value; + InputPort ip = m_mainGraphInstance.CurrentMasterNode.InputPorts.Find( x => x.Name == name ); + + if( op != null && ip != null && ip.Visible ) + { + var iNode = UIUtils.GetNode( ip.NodeId ); + var oNode = UIUtils.GetNode( op.NodeId ); + ip.ConnectTo( oNode.UniqueId, op.PortId, op.DataType, false ); + op.ConnectTo( iNode.UniqueId, ip.PortId, ip.DataType, ip.TypeLocked ); + + iNode.OnInputPortConnected( ip.PortId, oNode.UniqueId, op.PortId ); + oNode.OnOutputPortConnected( op.PortId, iNode.UniqueId, ip.PortId ); + } + } + } + m_savedList.Clear(); + } + + public Vector2 TranformPosition( Vector2 pos ) + { + return pos * m_cameraZoom - m_cameraOffset; + } + + public void UpdateTabTitle() + { + if( m_isShaderFunctionWindow ) + { + if( m_openedShaderFunction != null ) + { + this.titleContent.text = GenerateTabTitle( m_openedShaderFunction.FunctionName ); + } + } + else + { + if( m_selectionMode == ASESelectionMode.Material ) + { + this.titleContent.text = GenerateTabTitle( m_mainGraphInstance.CurrentMaterial.name ); + } + else + { + this.titleContent.text = GenerateTabTitle( m_mainGraphInstance.CurrentShader.name ); + } + } + } + + public ParentGraph CustomGraph + { + get { return m_customGraph; } + set { m_customGraph = value; } + } + + public ParentGraph CurrentGraph + { + get + { + if( m_customGraph != null ) + return m_customGraph; + + return m_mainGraphInstance; + } + } + + public void RefreshAvaibleNodes() + { + if( m_contextMenu != null && m_mainGraphInstance != null ) + { + m_contextMenu.RefreshNodes( m_mainGraphInstance ); + m_paletteWindow.ForceUpdate = true; + m_contextPalette.ForceUpdate = true; + m_refreshAvailableNodes = false; + } + } + + public void LateRefreshAvailableNodes() + { + m_refreshAvailableNodes = true; + } + + public ParentGraph OutsideGraph { get { return m_mainGraphInstance; } } + + public bool ShaderIsModified + { + get { return m_shaderIsModified; } + set + { + m_shaderIsModified = value && UIUtils.DirtyMask; + + m_toolsWindow.SetStateOnButton( ToolButtonType.Save, m_shaderIsModified ? 1 : 0 ); + if( !IsShaderFunctionWindow ) + { + MasterNode masterNode = m_mainGraphInstance.CurrentMasterNode; + if( masterNode != null && masterNode.CurrentShader != null ) + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Update, m_shaderIsModified ? 0 : 2 ); + UpdateTabTitle( masterNode.ShaderName, m_shaderIsModified ); + } + else + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Update, 1 ); + } + + //if( m_mainGraphInstance.CurrentStandardSurface != null ) + // UpdateTabTitle( m_mainGraphInstance.CurrentStandardSurface.ShaderName, m_shaderIsModified ); + } + else + { + m_toolsWindow.SetStateOnButton( ToolButtonType.Update, m_shaderIsModified ? 0 : 2 ); + if( m_mainGraphInstance.CurrentShaderFunction != null ) + UpdateTabTitle( m_mainGraphInstance.CurrentShaderFunction.FunctionName, m_shaderIsModified ); + } + + } + } + public void MarkToRepaint() { m_repaintIsDirty = true; } + public void RequestSave() { m_markedToSave = true; } + public void RequestRepaint() { m_repaintIsDirty = true; } + public OptionsWindow Options { get { return m_optionsWindow; } } + public GraphContextMenu ContextMenuInstance { get { return m_contextMenu; } set { m_contextMenu = value; } } + public ShortcutsManager ShortcutManagerInstance { get { return m_shortcutManager; } } + + public bool GlobalPreview + { + get { return m_globalPreview; } + set { m_globalPreview = value; } + } + + public bool GlobalShowInternalData + { + get { return m_globalShowInternalData; } + set { m_globalShowInternalData = value; } + } + + public double EditorTime + { + get { return m_time; } + set { m_time = value; } + } + + public ASESelectionMode CurrentSelection + { + get { return m_selectionMode; } + set + { + m_selectionMode = value; + switch( m_selectionMode ) + { + default: + case ASESelectionMode.Shader: + { + m_toolsWindow.BorderStyle = UIUtils.GetCustomStyle( CustomStyle.ShaderBorder ); + } + break; + case ASESelectionMode.Material: + { + m_toolsWindow.BorderStyle = UIUtils.GetCustomStyle( CustomStyle.MaterialBorder ); + } + break; + case ASESelectionMode.ShaderFunction: + { + m_toolsWindow.BorderStyle = UIUtils.GetCustomStyle( CustomStyle.ShaderFunctionBorder ); + } + break; + } + } + } + + public bool LiveShaderEditing + { + get { return m_liveShaderEditing; } + set + { + m_liveShaderEditing = value; + m_innerEditorVariables.LiveMode = m_liveShaderEditing; + UpdateLiveUI(); + } + } + + public NodeAvailability CurrentNodeAvailability + { + get { return m_currentNodeAvailability; } + set + { + NodeAvailability cache = m_currentNodeAvailability; + m_currentNodeAvailability = value; + + if( cache != value ) + RefreshAvaibleNodes(); + } + } + public string GUID + { + get + { + if( m_isShaderFunctionWindow ) + { + return m_openedShaderFunction != null ? AssetDatabase.AssetPathToGUID( AssetDatabase.GetAssetPath( m_openedShaderFunction ) ) : string.Empty; + } + else + { + return m_mainGraphInstance.CurrentShader != null ? AssetDatabase.AssetPathToGUID( AssetDatabase.GetAssetPath( m_mainGraphInstance.CurrentShader ) ) : string.Empty; + } + } + } + public List<Toast> Messages { get { return m_messages; } set { m_messages = value; } } + public float MaxMsgWidth { get { return m_maxMsgWidth; } set { m_maxMsgWidth = value; } } + public bool MaximizeMessages { get { return m_maximizeMessages; } set { m_maximizeMessages = value; } } + public void InvalidateAlt() { m_altAvailable = false; } + public PaletteWindow CurrentPaletteWindow { get { return m_paletteWindow; } } + public PreMadeShaders PreMadeShadersInstance { get { return m_preMadeShaders; } } + public Rect CameraInfo { get { return m_cameraInfo; } } + public Vector2 TranformedMousePos { get { return m_currentMousePos2D * m_cameraZoom - m_cameraOffset; } } + public Vector2 TranformedKeyEvtMousePos { get { return m_keyEvtMousePos2D * m_cameraZoom - m_cameraOffset; } } + public PalettePopUp PalettePopUpInstance { get { return m_palettePopup; } } + public DuplicatePreventionBuffer DuplicatePrevBufferInstance { get { return m_duplicatePreventionBuffer; } } + public NodeParametersWindow ParametersWindow { get { return m_nodeParametersWindow; } } + public NodeExporterUtils CurrentNodeExporterUtils { get { return m_nodeExporterUtils; } } + public AmplifyShaderFunction OpenedShaderFunction { get { return m_openedShaderFunction; } } + public DrawInfo CameraDrawInfo { get { return m_drawInfo; } } + public string Lastpath { get { return m_lastpath; } set { m_lastpath = value; } } + public string LastOpenedLocation { get { return m_lastOpenedLocation; } set { m_lastOpenedLocation = value; } } + public float AvailableCanvasWidth { get { return ( m_cameraInfo.width - m_paletteWindow.RealWidth - m_nodeParametersWindow.RealWidth ); } } + public float AvailableCanvasHeight { get { return ( m_cameraInfo.height ); } } + public float CameraZoom { get { return m_cameraZoom; } set { m_cameraZoom = value; m_zoomChanged = true; } } + public int GraphCount { get { return m_graphCount; } set { m_graphCount = value; } } + public bool ForceAutoPanDir { get { return m_forceAutoPanDir; } set { m_forceAutoPanDir = value; } } + public bool OpenedAssetFromNode { get { return m_openedAssetFromNode; } set { m_openedAssetFromNode = value; } } + public bool IsShaderFunctionWindow { get { return m_isShaderFunctionWindow; } set { m_isShaderFunctionWindow = value; } } + public bool NodesLoadedCorrectly { get { return m_nodesLoadedCorrectly; } set { m_nodesLoadedCorrectly = value; } } + public double CurrentInactiveTime { get { return m_currentInactiveTime; } } + public string ReplaceMasterNodeData { get { return m_replaceMasterNodeData; } } + public AvailableShaderTypes ReplaceMasterNodeType { get { return m_replaceMasterNodeType; } } + public NodeWireReferencesUtils WireReferenceUtils { get { return m_wireReferenceUtils; } } + public ContextPalette WindowContextPallete { get { return m_contextPalette; } } + // This needs to go to UIUtils + public Texture2D WireTexture { get { return m_wireTexture; } } + public Event CurrentEvent { get { return m_currentEvent; } } + public string CurrentCommandName { get { return m_currentCommandName; } } + public InnerWindowEditorVariables InnerWindowVariables { get { return m_innerEditorVariables; } } + public TemplatesManager TemplatesManagerInstance { get { return m_templatesManager; } } + public Material CurrentMaterial { get { return CurrentGraph.CurrentMaterial; } } + public Clipboard ClipboardInstance { get { return m_clipboard; } } + } +} |