5b28c9a977
commit bb3be793ca5db3df43679f2d6c34c75f768047a1
Author: SAIPO <grasste0403@hotmail.com>
Date: Wed Dec 22 07:46:07 2021 +0800
修改佛教Boss关卡和伊斯兰Boss关卡的粒子特效
commit 1987a63954402be8894f9cc9805545432afefa18
Author: SAIPO <grasste0403@hotmail.com>
Date: Tue Dec 21 20:55:05 2021 +0800
任务：编写shader，完善数据库类
1.完善了PlayerInfo类，用以数据库功能
1） 编写GetSqlData()函数，使用多线程获取用户信息，使用前请先设置公关变量name。
2） 编写CreateUser(string username)函数，在用户表内创建一个用户。
3） 编写hasName(string _searchName)函数，判断是否存在这个用户。
4） 编写GetBoardInfo(int WorldId)函数，获取指定世界的留言板链表。
5） 编写GetDeadInfo(int WorldId)函数，获取指定世界的死亡信息链表。
6） 编写CreateDead(int WorldId, Vector2 postion)函数，创建一条死亡信息。
7） 编写CreateBoard(int WorldId, Vector2 postion,string text)函数，创建一条留言信息。
8） 编写UpdatePlayerInfo()函数，将类里储存的信息上传到数据库。
2.实装相关Shader
1）完善以撒关卡的屏幕后特效，使其可以在发怒场景发出红色辉光。
2）完善以撒鬼魂的粒子，并且颜色和发怒与否关联。
3）实装以撒关卡的窗户辉光效果。
4）实装伊斯兰Boss关卡炸弹弹反的粒子特效。
5）实装伊斯兰Boss关卡的尘土特效（需要重做）
6）实装佛教Boss关卡的敲钟声波特效。
7）实装佛教Boss关卡的钟声受击灰尘（需要重做）
3.目前发现的bug
1）当人物恰好调到角落里会卡动画。
2）伊斯兰Boss关卡，特洛伊木马吐出的炸弹落到特效小怪上会闪退。
commit c06b842382051bc260d9f509491c683a41ca2a4c
Author: SAIPO <grasste0403@hotmail.com>
Date: Tue Dec 21 14:08:06 2021 +0800
Squashed commit of the following:
commit e7dcdec1d9913e283f42d42f72f1030f0c8b6fda
Author: Roman <1325980292@qq.com>
Date: Tue Dec 21 00:45:50 2021 +0800
任务：搭建前置关卡，编写演出逻辑
1.流程化游戏
（1.制作转移器，内含字典，根据玩家的静态属性“阶段”来决定到转移点后将会移动到哪一个场景
（2.制作转场器，水平方向从左到右
下班
commit 74f926815ec8d00fa051192eb3b978ff4b3c01a6
Author: Roman <1325980292@qq.com>
Date: Mon Dec 20 23:33:14 2021 +0800
任务：搭建前置关卡，编写演出逻辑
1.编写基督前置关卡
（1.放置平台、怪物和男童
（2.修改男童类，外加OnSaveEvent，OnSave时若有事件则触发该Event
（3.编写开幕演出，与yi前置类似
（4.编写男童解救演出
（（1.触发Fungus对话
（（2.对话结束后，开启通往上层的门
2.搭建村场景
（1.放置平台和元素
（2.为可动元素制作动画
3.为玩家添加static属性，进度。0：刚开，1进村，2通佛，3通伊，4.通基
4.制作死亡重开功能
（1.当玩家生命值降到0及以下，触发死亡事件
（2.死亡后reload当前场景，并设记录员，关闭某些事件和演出不再执行
*优化和修复
（1.尝试制作击中卡肉效果，目前打击感太弱。也可以尝试粒子效果
*至此，全部前置关卡搭建完毕，村场景搭建完毕。
*明天可以完成流程化，接下来就是填充剧情、UI、死亡标记和留言板等系统了
下班
commit f257b40d10373a13380e9c395fe94d6559a82a0f
Author: Roman <1325980292@qq.com>
Date: Sun Dec 19 23:57:44 2021 +0800
任务：搭建前置关卡，编写演出逻辑
1.编写佛教前置关开场演出
（*.休整地形，使得左边多出一块地面，方便演出正常运作
（*.项目后期再通过逻辑触发该演出，目前先用调试方式触发演出
（1.关闭空气墙
（2.修改玩家inputDir使玩家从屏幕外冲进到屏幕内部
（3.等待一段时间
（4.此时玩家应该走到某个合适的位置，停止玩家的inputDir
（5.等待一小段时间给玩家反应
（6.修改相机offset，使其对准对话的两个小怪
（7.等待一小段时间给玩家反应
（8.触发Fungus对话
（9.Fungus对话结束后，返回标记命令演出Main继续执行
*.修改NormalEnemy，添加标识isInFoStage，在Update中判断，若是，使该怪物水平方向上追踪玩家，可以参考爱欲品的Seek
（10.修改左边小怪的isInFoStage
（11.开启右边小怪的Path动画，表现其慌忙逃跑
（12.Invoke一个延时，等右边小怪逃出视野后删除它
（13.触发善后和结束事件
（14.重写善后事件，重新开启空气墙
2.搭建伊斯兰前置关卡
3.创建伊斯兰前置关卡演出
（1.关闭空气墙
（2.修改玩家inputDir使玩家从屏幕外冲进到屏幕内部
（3.等待一段时间
（4.此时玩家应该走到某个合适的位置，停止玩家的inputDir
（5.等待一小段时间给玩家反应
（6.触发善后与结束事件
4.创建玩家隔间触发事件
（1.是进入式触发器对象
（2.触发时Call隔间演出
5.编写隔间演出逻辑
（1.表现关门
（2.左右晃一下镜头，中心移动到左右门处，表示门被关闭
（3.镜头回到玩家处，同时压缩相机可移动范围更窄
（4.打开隔间墙壁的空气墙
（5.设置EndEvent为伊斯兰事件
6.编写召唤伊斯兰事件
（1.摘自木马的召唤攻击，稍作修改
（2.当召唤的伊斯兰全部挂了，触发隔间结束事件
7.编写隔间结束事件
（1.表现开门
（2.关闭隔间的空气墙
（3.重设相机移动范围
8.搭建基督前置关卡
*.至此，第一关、第二关前置关卡的逻辑基本开发完毕
*.明天能做完所有前置关，顺便应该能搭完村场景，后天可以开始搭建新系统，目前还差留言、死亡标记等系统等待编写
下班
commit cd22966ad7637a84c0f08c3a716d5ec549699749
Author: Roman <1325980292@qq.com>
Date: Sun Dec 19 14:12:05 2021 +0800
Squashed commit of the following:
commit 26aff356971bdc2c2a6a3bd444eeb50c4bf7ec14
Author: SAIPO <grasste0403@hotmail.com>
Date: Sun Dec 19 02:20:44 2021 +0800
导入近期制作的一些Shader
1.合并分支
2.完成了人物描边的流动shader制作，并且可以对Bloom屏幕后处理产生反应。
3.完成了基督教boss关卡，彩色窗户辉光的shader制作，可以对Bloom产生反应。
4.完成了伊斯兰教弹反的炸弹拖尾粒子shader的制作。
5.完成了火焰粒子shader的制作（可以用在基督教的以撒鬼魂上）。
6.完成了灰尘粒子像素化的shader制作。
7.完成了边缘扭曲的shader制作，可以用在一些树木上，让画面产生动感。
明天制作敲钟的声波Shader
# Conflicts:
# UserSettings/EditorUserSettings.asset
commit 26aff356971bdc2c2a6a3bd444eeb50c4bf7ec14
Author: SAIPO <grasste0403@hotmail.com>
Date: Sun Dec 19 02:20:44 2021 +0800
导入近期制作的一些Shader
1.合并分支
2.完成了人物描边的流动shader制作，并且可以对Bloom屏幕后处理产生反应。
3.完成了基督教boss关卡，彩色窗户辉光的shader制作，可以对Bloom产生反应。
4.完成了伊斯兰教弹反的炸弹拖尾粒子shader的制作。
5.完成了火焰粒子shader的制作（可以用在基督教的以撒鬼魂上）。
6.完成了灰尘粒子像素化的shader制作。
7.完成了边缘扭曲的shader制作，可以用在一些树木上，让画面产生动感。
明天制作敲钟的声波Shader
# Conflicts:
# Assets/Scenes/TeLuoYiStageTest.unity
# Assets/Shader/火焰粒子shader/particle.shadergraph
# Assets/Shader/灰尘粒子用shader/Pixel_My.shader
# Assets/Shader/灰尘粒子用shader/Unlit_Pixel_My 1.mat
# Assets/Shader/灰尘粒子用shader/Unlit_Pixel_My 2.mat
# Assets/Shader/灰尘粒子用shader/Unlit_Pixel_My.mat
# Logs/ApiUpdaterCheck.txt
# UserSettings/EditorUserSettings.asset
3110 lines
122 KiB
C#
3110 lines
122 KiB
C#
// Amplify Shader Editor - Visual Shader Editing Tool
|
|
// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
|
|
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
using System.Globalization;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace AmplifyShaderEditor
|
|
{
|
|
public enum ASEColorSpace
|
|
{
|
|
Auto,
|
|
Gamma,
|
|
Linear
|
|
}
|
|
|
|
public enum SurfaceInputs
|
|
{
|
|
DEPTH = 0,
|
|
UV_COORDS,
|
|
UV2_COORDS,
|
|
VIEW_DIR,
|
|
COLOR,
|
|
SCREEN_POS,
|
|
WORLD_POS,
|
|
WORLD_REFL,
|
|
WORLD_NORMAL,
|
|
VFACE,
|
|
INTERNALDATA
|
|
}
|
|
|
|
public enum CustomStyle
|
|
{
|
|
NodeWindowOff = 0,
|
|
NodeWindowOn,
|
|
NodeTitle,
|
|
NodeHeader,
|
|
CommentaryHeader,
|
|
ShaderLibraryTitle,
|
|
ShaderLibraryAddToList,
|
|
ShaderLibraryRemoveFromList,
|
|
ShaderLibraryOpenListed,
|
|
ShaderLibrarySelectionAsTemplate,
|
|
ShaderLibraryItem,
|
|
CommentaryTitle,
|
|
PortEmptyIcon,
|
|
PortFullIcon,
|
|
InputPortlabel,
|
|
OutputPortLabel,
|
|
CommentaryResizeButton,
|
|
CommentaryResizeButtonInv,
|
|
CommentaryBackground,
|
|
MinimizeButton,
|
|
MaximizeButton,
|
|
NodePropertiesTitle,
|
|
ShaderModeTitle,
|
|
MaterialModeTitle,
|
|
ShaderNoMaterialModeTitle,
|
|
PropertyValuesTitle,
|
|
ShaderModeNoShader,
|
|
MainCanvasTitle,
|
|
ShaderBorder,
|
|
MaterialBorder,
|
|
SamplerTextureRef,
|
|
SamplerTextureIcon,
|
|
CustomExpressionAddItem,
|
|
CustomExpressionRemoveItem,
|
|
CustomExpressionSmallAddItem,
|
|
CustomExpressionSmallRemoveItem,
|
|
ResetToDefaultInspectorButton,
|
|
SliderStyle,
|
|
ObjectPicker,
|
|
NodePropertyPicker,
|
|
NodePreviewExpander,
|
|
NodePreviewCollapser,
|
|
SamplerButton,
|
|
SamplerFrame,
|
|
CommentarySuperTitle,
|
|
MiniButtonTopLeft,
|
|
MiniButtonTopMid,
|
|
MiniButtonTopRight,
|
|
ShaderFunctionBorder,
|
|
ShaderFunctionMode,
|
|
RightShaderMode,
|
|
FlatBackground,
|
|
DocumentationLink,
|
|
GraphButtonIcon,
|
|
GraphButton,
|
|
NodeWindowOffSquare,
|
|
NodeHeaderSquare,
|
|
NodeWindowOnSquare,
|
|
ConsoleLogMessage,
|
|
ConsoleLogCircle
|
|
}
|
|
|
|
public enum MasterNodePortCategory
|
|
{
|
|
Vertex = 1 << 0,
|
|
Fragment = 1 << 1,
|
|
Tessellation = 1 << 2,
|
|
Debug = 1 << 3
|
|
}
|
|
|
|
public enum PortGenType
|
|
{
|
|
NonCustomLighting,
|
|
//Normal = 1 << 1,
|
|
//Emission = 1 << 2,
|
|
//Metallic = 1 << 3,
|
|
//Specular = 1 << 4,
|
|
CustomLighting
|
|
}
|
|
|
|
public struct NodeData
|
|
{
|
|
public MasterNodePortCategory Category;
|
|
public int OrderIndex;
|
|
public int GraphDepth;
|
|
public NodeData( MasterNodePortCategory category )
|
|
{
|
|
Category = category;
|
|
OrderIndex = 0;
|
|
GraphDepth = -1;
|
|
}
|
|
}
|
|
|
|
public struct NodeCastInfo
|
|
{
|
|
public int NodeId;
|
|
public int PortId;
|
|
public NodeCastInfo( int nodeId, int portId )
|
|
{
|
|
NodeId = nodeId;
|
|
PortId = portId;
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return NodeId.ToString() + PortId.ToString();
|
|
}
|
|
};
|
|
|
|
public struct ButtonClickId
|
|
{
|
|
public const int LeftMouseButton = 0;
|
|
public const int RightMouseButton = 1;
|
|
public const int MiddleMouseButton = 2;
|
|
}
|
|
|
|
public enum ASESelectionMode
|
|
{
|
|
Shader = 0,
|
|
Material,
|
|
ShaderFunction
|
|
}
|
|
|
|
public enum DrawOrder
|
|
{
|
|
Background,
|
|
Default
|
|
}
|
|
|
|
public enum NodeConnectionStatus
|
|
{
|
|
Not_Connected = 0,
|
|
Connected,
|
|
Error,
|
|
Island
|
|
}
|
|
|
|
public enum InteractionMode
|
|
{
|
|
Target,
|
|
Other,
|
|
Both
|
|
}
|
|
|
|
public enum FunctionNodeCategories
|
|
{
|
|
Custom,
|
|
CameraAndScreen,
|
|
ConstantsAndProperties,
|
|
Functions,
|
|
ImageEffects,
|
|
Light,
|
|
LogicalOperators,
|
|
MathOperators,
|
|
MatrixOperators,
|
|
Miscellaneous,
|
|
ObjectTransform,
|
|
SurfaceData,
|
|
Textures,
|
|
Time,
|
|
TrigonometryOperators,
|
|
UVCoordinates,
|
|
VectorOperators,
|
|
VertexData
|
|
}
|
|
|
|
public enum TransformSpaceFrom
|
|
{
|
|
Object = 0,
|
|
World,
|
|
View,
|
|
Tangent
|
|
}
|
|
|
|
public enum TransformSpaceTo
|
|
{
|
|
Object = 0,
|
|
World,
|
|
View,
|
|
Tangent,
|
|
Clip
|
|
}
|
|
|
|
public class UIUtils
|
|
{
|
|
public static string NewTemplateGUID;
|
|
public static int SerializeHelperCounter = 0;
|
|
public static bool IgnoreDeselectAll = false;
|
|
|
|
public static bool DirtyMask = true;
|
|
public static bool Initialized = false;
|
|
public static float HeaderMaxHeight;
|
|
public static float CurrentHeaderHeight;
|
|
public static GUISkin MainSkin = null;
|
|
public static GUIStyle PlusStyle;
|
|
public static GUIStyle MinusStyle;
|
|
public static GUIStyle RangedFloatSliderStyle;
|
|
public static GUIStyle RangedFloatSliderThumbStyle;
|
|
public static GUIStyle SwitchNodePopUp;
|
|
public static GUIStyle PropertyPopUp;
|
|
public static GUIStyle ObjectField;
|
|
public static GUIStyle PreviewExpander;
|
|
public static GUIStyle PreviewCollapser;
|
|
public static GUIStyle ObjectFieldThumb;
|
|
public static GUIStyle ObjectFieldThumbOverlay;
|
|
public static GUIStyle InspectorPopdropdownStyle;
|
|
public static GUIStyle InspectorPopdropdownFallback;
|
|
public static GUIStyle BoldErrorStyle;
|
|
public static GUIStyle BoldWarningStyle;
|
|
public static GUIStyle BoldInfoStyle;
|
|
public static GUIStyle Separator;
|
|
public static GUIStyle ToolbarMainTitle;
|
|
public static GUIStyle ToolbarSearchTextfield;
|
|
public static GUIStyle ToolbarSearchCancelButton;
|
|
public static GUIStyle MiniButtonTopLeft;
|
|
public static GUIStyle MiniButtonTopMid;
|
|
public static GUIStyle MiniButtonTopRight;
|
|
|
|
public static GUIStyle CommentaryTitle;
|
|
public static GUIStyle StickyNoteText;
|
|
public static GUIStyle InputPortLabel;
|
|
public static GUIStyle OutputPortLabel;
|
|
|
|
public static GUIStyle MiniObjectFieldThumbOverlay;
|
|
public static GUIStyle MiniSamplerButton;
|
|
|
|
public static GUIStyle NodeWindowOffSquare;
|
|
public static GUIStyle NodeHeaderSquare;
|
|
public static GUIStyle NodeWindowOnSquare;
|
|
public static GUIStyle InternalDataOnPort;
|
|
public static GUIStyle InternalDataBackground;
|
|
|
|
public static GUIStyle GraphButtonIcon;
|
|
public static GUIStyle GraphButton;
|
|
public static GUIStyle GraphDropDown;
|
|
|
|
public static GUIStyle EmptyStyle = new GUIStyle();
|
|
|
|
public static GUIStyle ConsoleLogLabel;
|
|
public static GUIStyle ConsoleLogMessage;
|
|
public static GUIStyle ConsoleLogCircle;
|
|
|
|
public static GUIStyle TooltipBox;
|
|
public static GUIStyle Box;
|
|
public static GUIStyle Button;
|
|
public static GUIStyle TextArea;
|
|
public static GUIStyle Label;
|
|
public static GUIStyle Toggle;
|
|
public static GUIStyle Textfield;
|
|
|
|
public static GUIStyle UnZoomedNodeTitleStyle;
|
|
public static GUIStyle UnZoomedPropertyValuesTitleStyle;
|
|
public static GUIStyle UnZoomedInputPortStyle;
|
|
public static GUIStyle UnZoomedOutputPortPortStyle;
|
|
|
|
// Node Property Menu items
|
|
public static GUIStyle MenuItemToggleStyle;
|
|
public static GUIStyle MenuItemEnableStyle;
|
|
public static GUIStyle MenuItemBackgroundStyle;
|
|
public static GUIStyle MenuItemToolbarStyle;
|
|
public static GUIStyle MenuItemInspectorDropdownStyle;
|
|
|
|
public static GUIStyle FloatIntPickerONOFF;
|
|
|
|
public static bool UsingProSkin = false;
|
|
|
|
public static Texture ShaderIcon { get { return EditorGUIUtility.IconContent( "Shader Icon" ).image; } }
|
|
public static Texture MaterialIcon { get { return EditorGUIUtility.IconContent( "Material Icon" ).image; } }
|
|
|
|
//50be8291f9514914aa55c66c49da67cf
|
|
public static Texture ShaderFunctionIcon { get { return AssetDatabase.LoadAssetAtPath<Texture>( AssetDatabase.GUIDToAssetPath( "50be8291f9514914aa55c66c49da67cf" ) ); } }
|
|
|
|
public static Texture2D WireNodeSelection = null;
|
|
public static Texture2D SliderButton = null;
|
|
|
|
public static Texture2D SmallErrorIcon = null;
|
|
public static Texture2D SmallWarningIcon = null;
|
|
public static Texture2D SmallInfoIcon = null;
|
|
|
|
public static Texture2D CheckmarkIcon = null;
|
|
public static Texture2D PopupIcon = null;
|
|
|
|
public static Texture2D MasterNodeOnTexture = null;
|
|
public static Texture2D MasterNodeOffTexture = null;
|
|
|
|
public static Texture2D GPUInstancedOnTexture = null;
|
|
public static Texture2D GPUInstancedOffTexture = null;
|
|
|
|
public static GUIContent LockIconOpen = null;
|
|
public static GUIContent LockIconClosed = null;
|
|
|
|
public static GUIContent FloatIntIconON = null;
|
|
public static GUIContent FloatIntIconOFF = null;
|
|
|
|
public static bool ShowContextOnPick = true;
|
|
|
|
private static AmplifyShaderEditorWindow m_currentWindow = null;
|
|
public static AmplifyShaderEditorWindow CurrentWindow
|
|
{
|
|
get
|
|
{
|
|
if( m_currentWindow == null )
|
|
{
|
|
for( int i = 0 ; i < IOUtils.AllOpenedWindows.Count ; i++ )
|
|
{
|
|
if( IOUtils.AllOpenedWindows[ i ] != null )
|
|
{
|
|
m_currentWindow = IOUtils.AllOpenedWindows[ i ];
|
|
}
|
|
else
|
|
{
|
|
//Debug.Log("No Window Found!");
|
|
}
|
|
}
|
|
}
|
|
return m_currentWindow;
|
|
}
|
|
set { m_currentWindow = value; }
|
|
}
|
|
|
|
public static Vector2 PortsSize;
|
|
public static Vector3 PortsDelta;
|
|
public static Vector3 ScaledPortsDelta;
|
|
|
|
public static RectOffset RectOffsetZero;
|
|
public static RectOffset RectOffsetOne;
|
|
public static RectOffset RectOffsetTwo;
|
|
public static RectOffset RectOffsetThree;
|
|
public static RectOffset RectOffsetFour;
|
|
public static RectOffset RectOffsetFive;
|
|
public static RectOffset RectOffsetSix;
|
|
|
|
public static Material LinearMaterial = null;
|
|
public static Shader IntShader = null;
|
|
public static Shader FloatShader = null;
|
|
public static Shader Vector2Shader = null;
|
|
public static Shader Vector3Shader = null;
|
|
public static Shader Vector4Shader = null;
|
|
public static Shader ColorShader = null;
|
|
public static Shader Texture2DShader = null;
|
|
public static Shader MaskingShader = null;
|
|
|
|
public static bool InhibitMessages = false;
|
|
|
|
|
|
private static int m_shaderIndentLevel = 0;
|
|
private static string m_shaderIndentTabs = string.Empty;
|
|
|
|
//Label Vars
|
|
|
|
private static TextAnchor m_alignment;
|
|
private static TextClipping m_clipping;
|
|
private static bool m_wordWrap;
|
|
private static int m_fontSize;
|
|
private static Color m_fontColor;
|
|
private static FontStyle m_fontStyle;
|
|
|
|
|
|
private static string NumericNamePattern = @"^\d";
|
|
private static System.Globalization.TextInfo m_textInfo;
|
|
private static string m_latestOpenedFolder = string.Empty;
|
|
private static Dictionary<int , UndoParentNode> m_undoHelper = new Dictionary<int , UndoParentNode>();
|
|
|
|
private static Dictionary<string , int> AvailableKeywordsDict = new Dictionary<string , int>();
|
|
public static readonly string[] AvailableKeywords =
|
|
{
|
|
"Custom",
|
|
"ETC1_EXTERNAL_ALPHA",
|
|
"PIXELSNAP_ON",
|
|
"UNITY_PASS_FORWARDBASE",
|
|
"UNITY_PASS_FORWARDADD",
|
|
"UNITY_PASS_DEFERRED",
|
|
"UNITY_PASS_SHADOWCASTER",
|
|
"UNITY_INSTANCING_ENABLED",
|
|
"DIRECTIONAL_COOKIE"
|
|
|
|
};
|
|
|
|
private static Dictionary<string , int> AvailableURPKeywordsDict = new Dictionary<string , int>();
|
|
public static readonly string[] AvailableURPKeywords =
|
|
{
|
|
"Custom",
|
|
"ETC1_EXTERNAL_ALPHA",
|
|
"PIXELSNAP_ON",
|
|
"SHADERPASS_EXTRA_PREPASS",
|
|
"SHADERPASS_FORWARD",
|
|
"SHADERPASS_SHADOWCASTER",
|
|
"SHADERPASS_DEPTHONLY",
|
|
"SHADERPASS_META",
|
|
"SHADERPASS_2D",
|
|
"UNITY_INSTANCING_ENABLED",
|
|
"DIRECTIONAL_COOKIE"
|
|
};
|
|
|
|
//private static Dictionary<string, string> URPToBultinKeywordsDict = new Dictionary<string, string>()
|
|
//{
|
|
// {"SHADERPASS_FORWARD","UNITY_PASS_FORWARDBASE"},
|
|
// {"SHADERPASS_SHADOWCASTER","UNITY_PASS_SHADOWCASTER"}
|
|
//};
|
|
|
|
//private static Dictionary<string, string> BultinToURPKeywordsDict = new Dictionary<string, string>()
|
|
//{
|
|
// {"UNITY_PASS_FORWARDBASE","SHADERPASS_FORWARD"},
|
|
// {"UNITY_PASS_SHADOWCASTER","SHADERPASS_SHADOWCASTER"}
|
|
//};
|
|
|
|
public static readonly string[] CategoryPresets =
|
|
{
|
|
"<Custom>",
|
|
"Camera And Screen",
|
|
"Constants And Properties",
|
|
"Functions",
|
|
"Image Effects",
|
|
"Light",
|
|
"Logical Operators",
|
|
"Math Operators",
|
|
"Matrix Operators",
|
|
"Miscellaneous",
|
|
"Object Transform",
|
|
"Surface Data",
|
|
"Textures",
|
|
"Time",
|
|
"Trigonometry Operators",
|
|
"UV Coordinates",
|
|
"Vector Operators",
|
|
"Vertex Data"
|
|
};
|
|
|
|
private static Dictionary<MasterNodePortCategory , int> m_portCategoryToArrayIdx = new Dictionary<MasterNodePortCategory , int>
|
|
{
|
|
{ MasterNodePortCategory.Vertex,0},
|
|
{ MasterNodePortCategory.Tessellation,0},
|
|
{ MasterNodePortCategory.Fragment,1},
|
|
{ MasterNodePortCategory.Debug,1}
|
|
};
|
|
|
|
private static Dictionary<string , string> m_reservedPropertyNames = new Dictionary<string , string>
|
|
{
|
|
{ "UNITY_MATRIX_MVP", string.Empty},
|
|
{ "UNITY_MATRIX_MV", string.Empty},
|
|
{ "UNITY_MATRIX_V", string.Empty},
|
|
{ "UNITY_MATRIX_P", string.Empty},
|
|
{ "UNITY_MATRIX_VP", string.Empty},
|
|
{ "UNITY_MATRIX_T_MV", string.Empty},
|
|
{ "UNITY_MATRIX_IT_MV", string.Empty},
|
|
{ "UNITY_MATRIX_TEXTURE0", string.Empty},
|
|
{ "UNITY_MATRIX_TEXTURE1", string.Empty},
|
|
{ "UNITY_MATRIX_TEXTURE2", string.Empty},
|
|
{ "UNITY_MATRIX_TEXTURE3", string.Empty},
|
|
{ "_Object2World", string.Empty},
|
|
{ "_WorldSpaceCameraPos", string.Empty},
|
|
{ "unity_Scale", string.Empty},
|
|
{ "_ModelLightColor", string.Empty},
|
|
{ "_SpecularLightColor", string.Empty},
|
|
{ "_ObjectSpaceLightPos", string.Empty},
|
|
{ "_Light2World", string.Empty},
|
|
{ "_World2Light", string.Empty},
|
|
{ "_Object2Light", string.Empty},
|
|
{ "_Time", string.Empty},
|
|
{ "_SinTime", string.Empty},
|
|
{ "_CosTime", string.Empty},
|
|
{ "unity_DeltaTime", string.Empty},
|
|
{ "_ProjectionParams", string.Empty},
|
|
{ "_ScreenParams", string.Empty}
|
|
};
|
|
|
|
private static Dictionary<string , string> m_exampleMaterialIDs = new Dictionary<string , string>()
|
|
{
|
|
//Community
|
|
{"2Sided", "8ebbbf2c99a544ca780a2573ef1450fc" },
|
|
{"DissolveBurn", "f144f2d7ff3daf349a2b7f0fd81ec8ac" },
|
|
{"MourEnvironmentGradient", "b64adae401bc073408ac7bff0993c107" },
|
|
{"ForceShield", "0119aa6226e2a4cfdb6c9a5ba9df7820" },
|
|
{"HighlightAnimated", "3d232e7526f6e426cab994cbec1fc287" },
|
|
{"Hologram", "b422c600f1c3941b8bc7e95db33476ad" },
|
|
{"LowPolyWater", "0557703d3791a4286a62f8ee709d5bef"},
|
|
//Official
|
|
{"AnimatedFire", "63ea5eae6d954a14292033589d0d4275" },
|
|
{"AnimatedFire-ShaderFunction", "9c6c9fcb82afe874a825a9e680e694b2" },
|
|
{"BurnEffect", "0b019675a8064414b97862a02f644166" },
|
|
{"CubemapReflections", "2c299f827334e9c459a60931aea62260" },
|
|
{"DitheringFade", "610507217b7dcad4d97e6e03e9844171" },
|
|
{"DoubleLayerCustomSurface", "846aec4914103104d99e9e31a217b548" },
|
|
{"NormalExtrusion", "70a5800fbba039f46b438a2055bc6c71" },
|
|
{"MatcapSample", "da8aaaf01fe8f2b46b2fbcb803bd7af4" },
|
|
{"ParallaxMappingIterations", "a0cea9c3f318ac74d89cd09134aad000" },
|
|
{"SandPOM", "905481dc696211145b88dc4bac2545f3" },
|
|
{"ParallaxWindow", "63ad0e7afb1717b4e95adda8904ab0c3" },
|
|
{"LocalPosCutoff", "fed8c9d33a691084c801573feeed5a62" },
|
|
{"ImprovedReadFromAtlasTiled", "941b31b251ea8e74f9198d788a604c9b" },
|
|
{"ReadFromAtlasTiled", "2d5537aa702f24645a1446dc3be92bbf" },
|
|
{"ReflectRefractSoapBubble", "a844987c9f2e7334abaa34f12feda3b9" },
|
|
{"RimLight", "e2d3a4d723cf1dc4eab1d919f3324dbc" },
|
|
{"RefractedShadows", "11818aa28edbeb04098f3b395a5bfc1d" },
|
|
{"TextureArray", "0f572993ab788a346aea45f2f797b7fa" },
|
|
{"ObjectNormalRefraction", "f1a0a645876302547b608ce881c94e6d" },
|
|
{"ShaderBallInterior", "e47ee174f55b6144b9c1a942bb23d82a" },
|
|
{"ScreenSpaceCurvature", "2e794cb9b3900b043a37ba28cdc2f907" },
|
|
{"ScreenSpaceDetail", "3a0163d12fede4d47a1f818a66a115de" },
|
|
{"SimpleNoise", "cc167bc6c2063a14f84a5a77be541194" },
|
|
{"SimpleBlur", "1d283ff911af20e429180bb15d023661" },
|
|
{"SimpleGPUInstancing", "9d609a7c8d00c7c4c9bdcdcdba154b81" },
|
|
{"SimpleLambert", "54b29030f7d7ffe4b84f2f215dede5ac" },
|
|
{"SimpleRefraction", "58c94d2f48acdc049a53b4ca53d6d98a" },
|
|
{"SimpleTexture", "9661085a7d249a54c95078ac8e7ff004" },
|
|
{"SnowAccum", "e3bd639f50ae1a247823079047a8dc01" },
|
|
{"StencilDiffuse01", "9f47f529fdeddd948a2d2722f73e6ac4" },
|
|
{"StencilMask01", "6f870834077d59b44ac421c36f619d59" },
|
|
{"StencilDiffuse02", "11cdb862d5ba68c4eae526765099305b" },
|
|
{"StencilMask02", "344696733b065c646b18c1aa2eacfdb7" },
|
|
{"StencilDiffuse03", "75e851f6c686a5f42ab900222b29355b" },
|
|
{"StencilMask03", "c7b3018ad495c6b479f2e3f8564aa6dc" },
|
|
{"SubstanceExample", "a515e243b476d7e4bb37eb9f82c87a12" },
|
|
{"AnimatedRefraction", "e414af1524d258047bb6b82b8860062c" },
|
|
{"Tessellation", "efb669a245f17384c88824d769d0087c" },
|
|
{"Translucency", "842ba3dcdd461ea48bdcfcea316cbcc4" },
|
|
{"Transmission", "1b21506b7afef734facfc42c596caa7b" },
|
|
{"Transparency", "e323a62068140c2408d5601877e8de2c" },
|
|
{"TriplanarProjection", "663d512de06d4e24db5205c679f394cb" },
|
|
{"TwoSideWithFace", "c953c4b601ba78e4f870d24d038b67f6" },
|
|
{"Ground", "48df9bdf7b922d94bb3167e6db39c943" },
|
|
{"WaterSample", "288137d67ce790e41903020c572ab4d7" },
|
|
{"WorldPosSlices", "013cc03f77f3d034692f902db8928787" }
|
|
};
|
|
|
|
private static Dictionary<TextureType , string> m_textureTypeToCgType = new Dictionary<TextureType , string>()
|
|
{
|
|
{TextureType.Texture1D, "sampler1D" },
|
|
{TextureType.Texture2D, "sampler2D" },
|
|
{TextureType.Texture3D, "sampler3D" },
|
|
{TextureType.Cube , "samplerCUBE"},
|
|
{TextureType.Texture2DArray, "sampler2DArray" },
|
|
{TextureType.ProceduralTexture, "sampler2D" }
|
|
};
|
|
|
|
|
|
private static Dictionary<string , Color> m_nodeCategoryToColor = new Dictionary<string , Color>()
|
|
{
|
|
{ "Master", new Color( 0.6f, 0.52f, 0.43f, 1.0f )},
|
|
{ "Default", new Color( 0.26f, 0.35f, 0.44f, 1.0f )},
|
|
{ "Vertex Data", new Color( 0.8f, 0.07f, 0.18f, 1.0f)},//new Color( 0.75f, 0.10f, 0.30f, 1.0f )},
|
|
{ "Math Operators", new Color( 0.26f, 0.35f, 0.44f, 1.0f )},//new Color( 0.10f, 0.27f, 0.45f, 1.0f) },
|
|
{ "Logical Operators", new Color( 0.0f, 0.55f, 0.45f, 1.0f)},//new Color( 0.11f, 0.28f, 0.47f, 1.0f) },
|
|
{ "Trigonometry Operators", new Color( 0.1f, 0.20f, 0.35f, 1.0f)},//new Color( 0.8f, 0.07f, 0.18f, 1.0f)},
|
|
{ "Image Effects", new Color( 0.5f, 0.2f, 0.90f, 1.0f)},//new Color( 0.12f, 0.47f, 0.88f, 1.0f)},
|
|
{ "Miscellaneous", new Color( 0.49f, 0.32f, 0.60f, 1.0f)},
|
|
{ "Camera And Screen", new Color( 0.75f, 0.10f, 0.30f, 1.0f )},//new Color( 0.17f, 0.22f, 0.07f, 1.0f) },
|
|
{ "Constants And Properties", new Color( 0.42f, 0.70f, 0.22f, 1.0f) },
|
|
{ "Surface Data", new Color( 0.92f, 0.73f, 0.03f, 1.0f)},
|
|
{ "Matrix Transform", new Color( 0.09f, 0.43f, 0.2f, 1.0f) },
|
|
{ "Time", new Color( 0.25f, 0.25f, 0.25f, 1.0f)},//new Color( 0.89f, 0.59f, 0.0f, 1.0f) },
|
|
{ "Functions", new Color( 1.00f, 0.4f, 0.0f, 1.0f) },
|
|
{ "Vector Operators", new Color( 0.22f, 0.20f, 0.45f, 1.0f)},
|
|
{ "Matrix Operators", new Color( 0.45f, 0.9f, 0.20f, 1.0f) },
|
|
{ "Light", new Color( 1.0f, 0.9f, 0.0f, 1.0f) },
|
|
{ "Textures", new Color( 0.15f, 0.40f, 0.8f, 1.0f)},
|
|
{ "Commentary", new Color( 0.7f, 0.7f, 0.7f, 1.0f)},
|
|
{ "UV Coordinates", new Color( 0.89f, 0.59f, 0.0f, 1.0f) },
|
|
{ "Object Transform", new Color( 0.15f, 0.4f, 0.49f, 1.0f)},
|
|
{ "Vertex Transform", new Color( 0.15f, 0.4f, 0.49f, 1.0f)}
|
|
};
|
|
|
|
private static Dictionary<ToolButtonType , List<string>> m_toolButtonTooltips = new Dictionary<ToolButtonType , List<string>>
|
|
{
|
|
{ ToolButtonType.New, new List<string>() { "Create new shader." } },
|
|
{ ToolButtonType.Open, new List<string>() { "Open existing shader." } },
|
|
{ ToolButtonType.Save, new List<string>() { "No changes to save.", "Save current changes." } },
|
|
{ ToolButtonType.Library, new List<string>() { "Lists custom shader selection." } },
|
|
{ ToolButtonType.Options, new List<string>() { "Open Options menu." } },
|
|
{ ToolButtonType.Update, new List<string>() { "Open or create a new shader first.", "Click to enable to update current shader.", "Shader up-to-date." } },
|
|
{ ToolButtonType.Live, new List<string>() { "Open or create a new shader first.", "Click to enable live shader preview", "Click to enable live shader and material preview." , "Live preview active, click to disable." } },
|
|
{ ToolButtonType.TakeScreenshot, new List<string>() { "Take screenshot", "Take screenshot" }},
|
|
{ ToolButtonType.Share, new List<string>() { "Share selection", "Share selection" }},
|
|
{ ToolButtonType.CleanUnusedNodes, new List<string>() { "No unconnected nodes to clean.", "Remove all nodes not connected( directly or indirectly) to the master node." }},
|
|
{ ToolButtonType.Help, new List<string>() { "Show help window." } },
|
|
{ ToolButtonType.FocusOnMasterNode,new List<string>() { "Focus on active master node." } },
|
|
{ ToolButtonType.FocusOnSelection, new List<string>() { "Focus on selection fit to screen ( if none selected )." } }
|
|
};
|
|
|
|
private static Color[] m_dataTypeToColorMonoMode = { new Color( 0.5f , 0.5f , 0.5f , 1.0f ) , Color.white };
|
|
private static Dictionary<WirePortDataType , Color> m_dataTypeToColor = new Dictionary<WirePortDataType , Color>( new WirePortDataTypeComparer() )
|
|
{
|
|
{ WirePortDataType.OBJECT, Color.white},
|
|
{ WirePortDataType.SAMPLERSTATE,Color.white},
|
|
{ WirePortDataType.FLOAT, Color.gray},
|
|
{ WirePortDataType.FLOAT2, new Color(1f,1f,0f,1f)},
|
|
{ WirePortDataType.FLOAT3, new Color(0.5f,0.5f,1f,1f)},
|
|
{ WirePortDataType.FLOAT4, new Color(1f,0,1f,1f)},
|
|
{ WirePortDataType.FLOAT3x3, new Color(0.5f,1f,0.5f,1f)},
|
|
{ WirePortDataType.FLOAT4x4, new Color(0.5f,1f,0.5f,1f)},
|
|
{ WirePortDataType.COLOR, new Color(1f,0,1f,1f)},
|
|
{ WirePortDataType.INT, Color.white},
|
|
{ WirePortDataType.SAMPLER1D, new Color(1f,0.5f,0f,1f)},
|
|
{ WirePortDataType.SAMPLER2D, new Color(1f,0.5f,0f,1f)},
|
|
{ WirePortDataType.SAMPLER3D, new Color(1f,0.5f,0f,1f)},
|
|
{ WirePortDataType.SAMPLERCUBE, new Color(1f,0.5f,0f,1f)},
|
|
{ WirePortDataType.SAMPLER2DARRAY, new Color(1f,0.5f,0f,1f)}
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , string> m_dataTypeToName = new Dictionary<WirePortDataType , string>()
|
|
{
|
|
{ WirePortDataType.OBJECT, "Generic Object"},
|
|
{ WirePortDataType.FLOAT, "Float"},
|
|
{ WirePortDataType.FLOAT2, "Vector2"},
|
|
{ WirePortDataType.FLOAT3, "Vector3"},
|
|
{ WirePortDataType.FLOAT4, "Vector4"},
|
|
{ WirePortDataType.FLOAT3x3, "3x3 Matrix"},
|
|
{ WirePortDataType.FLOAT4x4, "4x4 Matrix"},
|
|
{ WirePortDataType.COLOR, "Color"},
|
|
{ WirePortDataType.INT, "Int"},
|
|
{ WirePortDataType.SAMPLER1D, "Sampler1D"},
|
|
{ WirePortDataType.SAMPLER2D, "Sampler2D"},
|
|
{ WirePortDataType.SAMPLER3D, "Sampler3D"},
|
|
{ WirePortDataType.SAMPLERCUBE, "SamplerCUBE"},
|
|
{ WirePortDataType.SAMPLER2DARRAY, "Sampler2DArray"},
|
|
{ WirePortDataType.SAMPLERSTATE,"Sampler State"},
|
|
};
|
|
|
|
private static Dictionary<SurfaceInputs , string> m_inputTypeDeclaration = new Dictionary<SurfaceInputs , string>()
|
|
{
|
|
{ SurfaceInputs.DEPTH, "{0} Depth : SV_Depth"},
|
|
{ SurfaceInputs.UV_COORDS, "{0}2 uv"},// texture uv must have uv or uv2 followed by the texture name
|
|
{ SurfaceInputs.UV2_COORDS, "{0}2 uv2"},
|
|
{ SurfaceInputs.VIEW_DIR, "{0}3 viewDir"},
|
|
{ SurfaceInputs.COLOR, Constants.ColorInput},
|
|
{ SurfaceInputs.SCREEN_POS, "{0}4 screenPos"},
|
|
{ SurfaceInputs.WORLD_POS, "{0}3 worldPos"},
|
|
{ SurfaceInputs.WORLD_REFL, "{0}3 worldRefl"},
|
|
{ SurfaceInputs.WORLD_NORMAL,"{0}3 worldNormal"},
|
|
{ SurfaceInputs.VFACE, Constants.VFaceInput},
|
|
{ SurfaceInputs.INTERNALDATA, Constants.InternalData}
|
|
};
|
|
|
|
private static Dictionary<SurfaceInputs , string> m_inputTypeName = new Dictionary<SurfaceInputs , string>()
|
|
{
|
|
{ SurfaceInputs.DEPTH, "Depth"},
|
|
{ SurfaceInputs.UV_COORDS, "uv"},// texture uv must have uv or uv2 followed by the texture name
|
|
{ SurfaceInputs.UV2_COORDS, "uv2"},
|
|
{ SurfaceInputs.VIEW_DIR, "viewDir"},
|
|
{ SurfaceInputs.COLOR, Constants.ColorVariable},
|
|
{ SurfaceInputs.SCREEN_POS, "screenPos"},
|
|
{ SurfaceInputs.WORLD_POS, "worldPos"},
|
|
{ SurfaceInputs.WORLD_REFL, "worldRefl"},
|
|
{ SurfaceInputs.WORLD_NORMAL, "worldNormal"},
|
|
{ SurfaceInputs.VFACE, Constants.VFaceVariable},
|
|
};
|
|
|
|
private static Dictionary<PrecisionType , string> m_precisionTypeToCg = new Dictionary<PrecisionType , string>()
|
|
{
|
|
{PrecisionType.Float, "float"},
|
|
{PrecisionType.Half, "half"},
|
|
{PrecisionType.Inherit, "float"}
|
|
};
|
|
|
|
private static Dictionary<VariableQualifiers , string> m_qualifierToCg = new Dictionary<VariableQualifiers , string>()
|
|
{
|
|
{ VariableQualifiers.In, string.Empty},
|
|
{VariableQualifiers.Out, "out"},
|
|
{VariableQualifiers.InOut, "inout"}
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , string> m_precisionWirePortToCgType = new Dictionary<WirePortDataType , string>()
|
|
{
|
|
{WirePortDataType.FLOAT, "{0}"},
|
|
{WirePortDataType.FLOAT2, "{0}2"},
|
|
{WirePortDataType.FLOAT3, "{0}3"},
|
|
{WirePortDataType.FLOAT4, "{0}4"},
|
|
{WirePortDataType.FLOAT3x3, "{0}3x3"},
|
|
{WirePortDataType.FLOAT4x4, "{0}4x4"},
|
|
{WirePortDataType.COLOR, "{0}4"},
|
|
{WirePortDataType.INT, "int"},
|
|
{WirePortDataType.SAMPLER1D, "sampler1D"},
|
|
{WirePortDataType.SAMPLER2D, "sampler2D"},
|
|
{WirePortDataType.SAMPLER3D, "sampler3D"},
|
|
{WirePortDataType.SAMPLERCUBE, "samplerCUBE"},
|
|
{WirePortDataType.SAMPLER2DARRAY, "sampler2DArray"},
|
|
{WirePortDataType.SAMPLERSTATE, "SamplerState"}
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , string> m_precisionWirePortToStandardMacroType = new Dictionary<WirePortDataType , string>()
|
|
{
|
|
{WirePortDataType.FLOAT, "{0}"},
|
|
{WirePortDataType.FLOAT2, "{0}2"},
|
|
{WirePortDataType.FLOAT3, "{0}3"},
|
|
{WirePortDataType.FLOAT4, "{0}4"},
|
|
{WirePortDataType.FLOAT3x3, "{0}3x3"},
|
|
{WirePortDataType.FLOAT4x4, "{0}4x4"},
|
|
{WirePortDataType.COLOR, "{0}4"},
|
|
{WirePortDataType.INT, "int"},
|
|
{WirePortDataType.SAMPLER1D, "sampler1D"},
|
|
{WirePortDataType.SAMPLER2D, "UNITY_DECLARE_TEX2D_NOSAMPLER("},
|
|
{WirePortDataType.SAMPLER3D, "UNITY_DECLARE_TEX3D_NOSAMPLER("},
|
|
{WirePortDataType.SAMPLERCUBE, "UNITY_DECLARE_TEXCUBE_NOSAMPLER("},
|
|
{WirePortDataType.SAMPLER2DARRAY, "UNITY_DECLARE_TEX2DARRAY_NOSAMPLER("},
|
|
{WirePortDataType.SAMPLERSTATE, "SamplerState"}
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , string> m_precisionWirePortToSRPMacroType = new Dictionary<WirePortDataType , string>()
|
|
{
|
|
{WirePortDataType.FLOAT, "{0}"},
|
|
{WirePortDataType.FLOAT2, "{0}2"},
|
|
{WirePortDataType.FLOAT3, "{0}3"},
|
|
{WirePortDataType.FLOAT4, "{0}4"},
|
|
{WirePortDataType.FLOAT3x3, "{0}3x3"},
|
|
{WirePortDataType.FLOAT4x4, "{0}4x4"},
|
|
{WirePortDataType.COLOR, "{0}4"},
|
|
{WirePortDataType.INT, "int"},
|
|
{WirePortDataType.SAMPLER1D, "sampler1D"},
|
|
{WirePortDataType.SAMPLER2D, "TEXTURE2D("},
|
|
{WirePortDataType.SAMPLER3D, "TEXTURE3D("},
|
|
{WirePortDataType.SAMPLERCUBE, "TEXTURECUBE("},
|
|
{WirePortDataType.SAMPLER2DARRAY, "TEXTURE2D_ARRAY("},
|
|
{WirePortDataType.SAMPLERSTATE, "SamplerState"}
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , string> m_wirePortToCgType = new Dictionary<WirePortDataType , string>()
|
|
{
|
|
{ WirePortDataType.FLOAT, "float"},
|
|
{WirePortDataType.FLOAT2, "float2"},
|
|
{WirePortDataType.FLOAT3, "float3"},
|
|
{WirePortDataType.FLOAT4, "float4"},
|
|
{WirePortDataType.FLOAT3x3, "float3x3"},
|
|
{WirePortDataType.FLOAT4x4, "float4x4"},
|
|
{WirePortDataType.COLOR, "float4"},
|
|
{WirePortDataType.INT, "int"},
|
|
{WirePortDataType.SAMPLER1D, "sampler1D"},
|
|
{WirePortDataType.SAMPLER2D, "sampler2D"},
|
|
{WirePortDataType.SAMPLER3D, "sampler3D"},
|
|
{WirePortDataType.SAMPLERCUBE, "samplerCUBE"},
|
|
{WirePortDataType.SAMPLER2DARRAY, "sampler2DArray"},
|
|
{WirePortDataType.UINT, "uint"},
|
|
{WirePortDataType.UINT4, "uint4"},
|
|
{WirePortDataType.SAMPLERSTATE, "SamplerState"}
|
|
};
|
|
|
|
private static Dictionary<KeyCode , string> m_keycodeToString = new Dictionary<KeyCode , string>()
|
|
{
|
|
{KeyCode.Alpha0,"0" },
|
|
{KeyCode.Alpha1,"1" },
|
|
{KeyCode.Alpha2,"2" },
|
|
{KeyCode.Alpha3,"3" },
|
|
{KeyCode.Alpha4,"4" },
|
|
{KeyCode.Alpha5,"5" },
|
|
{KeyCode.Alpha6,"6" },
|
|
{KeyCode.Alpha7,"7" },
|
|
{KeyCode.Alpha8,"8" },
|
|
{KeyCode.Alpha9,"9" }
|
|
};
|
|
|
|
private static Dictionary<WireStatus , Color> m_wireStatusToColor = new Dictionary<WireStatus , Color>()
|
|
{
|
|
{ WireStatus.Default,new Color(0.7f,0.7f,0.7f,1.0f) },
|
|
{WireStatus.Highlighted,Color.yellow },
|
|
{WireStatus.Selected,Color.white}
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , string> m_autoSwizzle = new Dictionary<WirePortDataType , string>()
|
|
{
|
|
{WirePortDataType.FLOAT, ".x"},
|
|
{WirePortDataType.FLOAT2, ".xy"},
|
|
{WirePortDataType.FLOAT3, ".xyz"},
|
|
{WirePortDataType.FLOAT4, ".xyzw"}
|
|
};
|
|
|
|
private static Dictionary<string , bool> m_unityNativeShaderPaths = new Dictionary<string , bool>
|
|
{
|
|
{ "Resources/unity_builtin_extra", true },
|
|
{ "Library/unity default resources", true }
|
|
};
|
|
|
|
private static Dictionary<WirePortDataType , int> m_portPriority = new Dictionary<WirePortDataType , int>()
|
|
{
|
|
{WirePortDataType.OBJECT, 0},
|
|
{WirePortDataType.SAMPLERSTATE, 0},
|
|
{WirePortDataType.SAMPLER1D, 0},
|
|
{WirePortDataType.SAMPLER2D, 0},
|
|
{WirePortDataType.SAMPLER3D, 0},
|
|
{WirePortDataType.SAMPLERCUBE, 0},
|
|
{WirePortDataType.SAMPLER2DARRAY, 0},
|
|
{WirePortDataType.FLOAT3x3, 1},
|
|
{WirePortDataType.FLOAT4x4, 2},
|
|
{WirePortDataType.INT, 3},
|
|
{WirePortDataType.UINT, 3},
|
|
{WirePortDataType.FLOAT, 4},
|
|
{WirePortDataType.FLOAT2, 5},
|
|
{WirePortDataType.FLOAT3, 6},
|
|
{WirePortDataType.FLOAT4, 7},
|
|
{WirePortDataType.COLOR, 7}
|
|
};
|
|
|
|
private static readonly string IncorrectInputConnectionErrorMsg = "Input Port {0} from node {1} has type {2}\nwhich is incompatible with connection of type {3} from port {4} on node {5}";
|
|
private static readonly string IncorrectOutputConnectionErrorMsg = "Output Port {0} from node {1} has type {2}\nwhich is incompatible with connection of type {3} from port {4} on node {5}";
|
|
private static readonly string NoVertexModeNodeWarning = "{0} is unable to generate code in vertex function";
|
|
|
|
private static float SwitchFixedHeight;
|
|
private static float SwitchFontSize;
|
|
private static RectOffset SwitchNodeBorder;
|
|
private static RectOffset SwitchNodeMargin;
|
|
private static RectOffset SwitchNodeOverflow;
|
|
private static RectOffset SwitchNodePadding;
|
|
|
|
private static RenderTexture m_dummyPreviewRT;
|
|
public static void ForceExampleShaderCompilation()
|
|
{
|
|
CurrentWindow.ForceMaterialsToUpdate( ref m_exampleMaterialIDs );
|
|
|
|
}
|
|
|
|
public static void Destroy()
|
|
{
|
|
if( IOUtils.AllOpenedWindows != null && IOUtils.AllOpenedWindows.Count > 0 )
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
IOUtils.AllOpenedWindows.Clear();
|
|
}
|
|
|
|
Initialized = false;
|
|
|
|
if( m_dummyPreviewRT != null )
|
|
m_dummyPreviewRT.Release();
|
|
|
|
ScriptableObject.DestroyImmediate( m_dummyPreviewRT );
|
|
|
|
m_dummyPreviewRT = null;
|
|
PlusStyle = null;
|
|
MinusStyle = null;
|
|
m_textInfo = null;
|
|
RangedFloatSliderStyle = null;
|
|
RangedFloatSliderThumbStyle = null;
|
|
PropertyPopUp = null;
|
|
ObjectField = null;
|
|
PreviewExpander = null;
|
|
PreviewCollapser = null;
|
|
MenuItemToggleStyle = null;
|
|
MenuItemEnableStyle = null;
|
|
MenuItemBackgroundStyle = null;
|
|
MenuItemToolbarStyle = null;
|
|
MenuItemInspectorDropdownStyle = null;
|
|
ObjectFieldThumb = null;
|
|
ObjectFieldThumbOverlay = null;
|
|
InspectorPopdropdownStyle = null;
|
|
InspectorPopdropdownFallback = null;
|
|
TooltipBox = null;
|
|
UnZoomedNodeTitleStyle = null;
|
|
UnZoomedPropertyValuesTitleStyle = null;
|
|
UnZoomedInputPortStyle = null;
|
|
UnZoomedOutputPortPortStyle = null;
|
|
ToolbarSearchTextfield = null;
|
|
ToolbarSearchCancelButton = null;
|
|
FloatIntPickerONOFF = null;
|
|
Box = null;
|
|
Button = null;
|
|
TextArea = null;
|
|
Label = null;
|
|
Toggle = null;
|
|
Textfield = null;
|
|
|
|
CommentaryTitle = null;
|
|
StickyNoteText = null;
|
|
InputPortLabel = null;
|
|
OutputPortLabel = null;
|
|
|
|
IntShader = null;
|
|
FloatShader = null;
|
|
Vector2Shader = null;
|
|
Vector3Shader = null;
|
|
Vector4Shader = null;
|
|
ColorShader = null;
|
|
Texture2DShader = null;
|
|
|
|
MaskingShader = null;
|
|
|
|
BoldErrorStyle = null;
|
|
BoldWarningStyle = null;
|
|
BoldInfoStyle = null;
|
|
Separator = null;
|
|
ToolbarMainTitle = null;
|
|
|
|
GraphButtonIcon = null;
|
|
GraphButton = null;
|
|
GraphDropDown = null;
|
|
|
|
ConsoleLogLabel = null;
|
|
ConsoleLogMessage = null;
|
|
ConsoleLogCircle = null;
|
|
|
|
MiniButtonTopLeft = null;
|
|
MiniButtonTopMid = null;
|
|
MiniButtonTopRight = null;
|
|
|
|
NodeWindowOffSquare = null;
|
|
NodeHeaderSquare = null;
|
|
NodeWindowOnSquare = null;
|
|
InternalDataOnPort = null;
|
|
InternalDataBackground = null;
|
|
|
|
MiniObjectFieldThumbOverlay = null;
|
|
MiniSamplerButton = null;
|
|
|
|
Resources.UnloadAsset( SmallErrorIcon );
|
|
SmallErrorIcon = null;
|
|
|
|
Resources.UnloadAsset( SmallWarningIcon );
|
|
SmallWarningIcon = null;
|
|
|
|
Resources.UnloadAsset( SmallInfoIcon );
|
|
SmallInfoIcon = null;
|
|
|
|
LockIconOpen = null;
|
|
LockIconClosed = null;
|
|
|
|
FloatIntIconON = null;
|
|
FloatIntIconOFF = null;
|
|
|
|
Resources.UnloadAsset( CheckmarkIcon );
|
|
CheckmarkIcon = null;
|
|
|
|
Resources.UnloadAsset( PopupIcon );
|
|
PopupIcon = null;
|
|
|
|
Resources.UnloadAsset( MasterNodeOnTexture );
|
|
MasterNodeOnTexture = null;
|
|
|
|
Resources.UnloadAsset( MasterNodeOffTexture );
|
|
MasterNodeOffTexture = null;
|
|
|
|
Resources.UnloadAsset( GPUInstancedOnTexture );
|
|
GPUInstancedOnTexture = null;
|
|
|
|
Resources.UnloadAsset( GPUInstancedOffTexture );
|
|
GPUInstancedOffTexture = null;
|
|
|
|
MainSkin = null;
|
|
|
|
if( LinearMaterial != null )
|
|
GameObject.DestroyImmediate( LinearMaterial );
|
|
|
|
LinearMaterial = null;
|
|
|
|
if( m_undoHelper == null )
|
|
{
|
|
m_undoHelper.Clear();
|
|
m_undoHelper = null;
|
|
}
|
|
ASEMaterialInspector.Instance = null;
|
|
}
|
|
|
|
public static void ResetMainSkin()
|
|
{
|
|
if( (object)MainSkin != null )
|
|
{
|
|
CurrentHeaderHeight = HeaderMaxHeight;
|
|
ScaledPortsDelta = PortsDelta;
|
|
MainSkin.textField.fontSize = (int)( Constants.TextFieldFontSize );
|
|
MainSkin.label.fontSize = (int)( Constants.DefaultFontSize );
|
|
MainSkin.customStyles[ (int)CustomStyle.NodeTitle ].fontSize = (int)( Constants.DefaultTitleFontSize );
|
|
|
|
InputPortLabel.fontSize = (int)( Constants.DefaultFontSize );
|
|
OutputPortLabel.fontSize = (int)( Constants.DefaultFontSize );
|
|
CommentaryTitle.fontSize = (int)( Constants.DefaultFontSize );
|
|
StickyNoteText.fontSize = (int)( Constants.DefaultFontSize );
|
|
}
|
|
}
|
|
|
|
public static void InitMainSkin()
|
|
{
|
|
MainSkin = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( IOUtils.MainSkinGUID ) , typeof( GUISkin ) ) as GUISkin;
|
|
Initialized = true;
|
|
Texture2D portTex = GetCustomStyle( CustomStyle.PortEmptyIcon ).normal.background;
|
|
PortsSize = new Vector2( portTex.width , portTex.height );
|
|
PortsDelta = new Vector3( 0.5f * PortsSize.x , 0.5f * PortsSize.y );
|
|
HeaderMaxHeight = MainSkin.customStyles[ (int)CustomStyle.NodeHeader ].normal.background.height;
|
|
|
|
RectOffsetZero = new RectOffset( 0 , 0 , 0 , 0 );
|
|
RectOffsetOne = new RectOffset( 1 , 1 , 1 , 1 );
|
|
RectOffsetTwo = new RectOffset( 2 , 2 , 2 , 2 );
|
|
RectOffsetThree = new RectOffset( 3 , 3 , 3 , 3 );
|
|
RectOffsetFour = new RectOffset( 4 , 4 , 4 , 4 );
|
|
RectOffsetFive = new RectOffset( 5 , 5 , 5 , 5 );
|
|
RectOffsetSix = new RectOffset( 6 , 6 , 6 , 6 );
|
|
|
|
PropertyPopUp = GetCustomStyle( CustomStyle.NodePropertyPicker );
|
|
ObjectField = new GUIStyle( (GUIStyle)"ObjectField" );
|
|
PreviewExpander = GetCustomStyle( CustomStyle.NodePreviewExpander );
|
|
PreviewCollapser = GetCustomStyle( CustomStyle.NodePreviewCollapser );
|
|
|
|
WireNodeSelection = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "bfe0b03d5d60cea4f9d4b2d1d121e592" ) , typeof( Texture2D ) ) as Texture2D;
|
|
SliderButton = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "dd563e33152bb6443b099b4139ceecb9" ) , typeof( Texture2D ) ) as Texture2D;
|
|
|
|
SmallErrorIcon = EditorGUIUtility.Load( "icons/d_console.erroricon.sml.png" ) as Texture2D;
|
|
SmallWarningIcon = EditorGUIUtility.Load( "icons/d_console.warnicon.sml.png" ) as Texture2D;
|
|
SmallInfoIcon = EditorGUIUtility.Load( "icons/d_console.infoicon.sml.png" ) as Texture2D;
|
|
|
|
LockIconOpen = new GUIContent( EditorGUIUtility.IconContent( "LockIcon-On" ) );
|
|
LockIconOpen.tooltip = "Click to unlock and customize the variable name";
|
|
LockIconClosed = new GUIContent( EditorGUIUtility.IconContent( "LockIcon" ) );
|
|
LockIconClosed.tooltip = "Click to lock and auto-generate the variable name";
|
|
|
|
if( UsingProSkin )
|
|
{
|
|
FloatIntIconON = new GUIContent( EditorGUIUtility.IconContent( "CircularToggle_ON" ) );
|
|
FloatIntIconOFF = new GUIContent( EditorGUIUtility.IconContent( "CircularToggle_OFF" ) );
|
|
}
|
|
else
|
|
{
|
|
FloatIntIconON = new GUIContent( ( AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "ac0860a6a77e29d4091ba790a17daa0f" ) , typeof( Texture2D ) ) as Texture2D ) );
|
|
FloatIntIconOFF = new GUIContent( ( AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "1aaca50d084b0bb43854f075ce2f302b" ) , typeof( Texture2D ) ) as Texture2D ) );
|
|
}
|
|
|
|
CommentaryTitle = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.CommentaryTitle ] );
|
|
StickyNoteText = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.CommentaryTitle ] );
|
|
StickyNoteText.wordWrap = true;
|
|
StickyNoteText.alignment = TextAnchor.UpperLeft;
|
|
InputPortLabel = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.InputPortlabel ] );
|
|
OutputPortLabel = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.OutputPortLabel ] );
|
|
|
|
CheckmarkIcon = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "e9c4642eaa083a54ab91406d8449e6ac" ) , typeof( Texture2D ) ) as Texture2D;
|
|
PopupIcon = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "d2384a227b4ac4943b73c8151393e502" ) , typeof( Texture2D ) ) as Texture2D;
|
|
|
|
BoldErrorStyle = new GUIStyle( (GUIStyle)"BoldLabel" );
|
|
BoldErrorStyle.normal.textColor = Color.red;
|
|
BoldErrorStyle.alignment = TextAnchor.MiddleCenter;
|
|
BoldWarningStyle = new GUIStyle( (GUIStyle)"BoldLabel" );
|
|
BoldWarningStyle.normal.textColor = Color.yellow;
|
|
BoldWarningStyle.alignment = TextAnchor.MiddleCenter;
|
|
BoldInfoStyle = new GUIStyle( (GUIStyle)"BoldLabel" );
|
|
BoldInfoStyle.normal.textColor = Color.white;
|
|
BoldInfoStyle.alignment = TextAnchor.MiddleCenter;
|
|
|
|
ToolbarMainTitle = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.MainCanvasTitle ] );
|
|
Separator = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.FlatBackground ] );
|
|
MiniButtonTopLeft = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.MiniButtonTopLeft ] );
|
|
MiniButtonTopMid = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.MiniButtonTopMid ] );
|
|
MiniButtonTopRight = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.MiniButtonTopRight ] );
|
|
|
|
InternalDataOnPort = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.NodeTitle ] );
|
|
InternalDataOnPort.fontSize = 8;
|
|
InternalDataOnPort.fontStyle = FontStyle.BoldAndItalic;
|
|
InternalDataBackground = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.NodeWindowOffSquare ] );
|
|
InternalDataBackground.normal.background = AssetDatabase.LoadAssetAtPath( AssetDatabase.GUIDToAssetPath( "330fd0c8f074a3c4f8042114a61a73d9" ) , typeof( Texture2D ) ) as Texture2D;
|
|
InternalDataBackground.overflow = RectOffsetOne;
|
|
|
|
MiniObjectFieldThumbOverlay = new GUIStyle( (GUIStyle)"ObjectFieldThumbOverlay" );
|
|
MiniSamplerButton = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.SamplerButton ] );
|
|
|
|
m_textInfo = new System.Globalization.CultureInfo( "en-US" , false ).TextInfo;
|
|
RangedFloatSliderStyle = new GUIStyle( GUI.skin.horizontalSlider );
|
|
RangedFloatSliderThumbStyle = new GUIStyle( GUI.skin.horizontalSliderThumb );
|
|
RangedFloatSliderThumbStyle.normal.background = SliderButton;
|
|
RangedFloatSliderThumbStyle.active.background = null;
|
|
RangedFloatSliderThumbStyle.hover.background = null;
|
|
RangedFloatSliderThumbStyle.focused.background = null;
|
|
RangedFloatSliderThumbStyle.overflow = new RectOffset( 1 , 1 , -4 , 4 );
|
|
RangedFloatSliderThumbStyle.margin = RectOffsetZero;
|
|
|
|
SwitchNodePopUp = new GUIStyle( (GUIStyle)"Popup" );
|
|
// RectOffset cannot be initiliazed on constructor
|
|
SwitchNodeBorder = new RectOffset( 4 , 15 , 3 , 3 );
|
|
SwitchNodeMargin = new RectOffset( 4 , 4 , 3 , 3 );
|
|
SwitchNodeOverflow = new RectOffset( 0 , 0 , -1 , 2 );
|
|
SwitchNodePadding = new RectOffset( 6 , 14 , 2 , 3 );
|
|
SwitchFixedHeight = 18;
|
|
SwitchFontSize = 10;
|
|
|
|
GraphButtonIcon = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.GraphButtonIcon ] );
|
|
GraphButton = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.GraphButton ] );
|
|
GraphDropDown = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.GraphButton ] );
|
|
GraphDropDown.padding.right = 20;
|
|
|
|
Box = new GUIStyle( MainSkin.box );
|
|
Button = new GUIStyle( GUI.skin.button );
|
|
TextArea = new GUIStyle( GUI.skin.textArea );
|
|
Label = new GUIStyle( GUI.skin.label );
|
|
Toggle = new GUIStyle( GUI.skin.toggle );
|
|
Textfield = new GUIStyle( GUI.skin.textField );
|
|
//ShaderIcon = EditorGUIUtility.IconContent( "Shader Icon" ).image;
|
|
//MaterialIcon = EditorGUIUtility.IconContent( "Material Icon" ).image;
|
|
|
|
ConsoleLogLabel = new GUIStyle( GUI.skin.label );
|
|
ConsoleLogMessage = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.ConsoleLogMessage ] );
|
|
ConsoleLogCircle = new GUIStyle( MainSkin.customStyles[ (int)CustomStyle.ConsoleLogCircle ] );
|
|
|
|
NodeWindowOffSquare = GetCustomStyle( CustomStyle.NodeWindowOffSquare );
|
|
NodeHeaderSquare = GetCustomStyle( CustomStyle.NodeHeaderSquare );
|
|
NodeWindowOnSquare = GetCustomStyle( CustomStyle.NodeWindowOnSquare );
|
|
|
|
UnZoomedNodeTitleStyle = new GUIStyle( GetCustomStyle( CustomStyle.NodeTitle ) );
|
|
UnZoomedNodeTitleStyle.fontSize = 13;
|
|
|
|
UnZoomedPropertyValuesTitleStyle = new GUIStyle( GetCustomStyle( CustomStyle.PropertyValuesTitle ) );
|
|
UnZoomedPropertyValuesTitleStyle.fontSize = 11;
|
|
|
|
UnZoomedInputPortStyle = new GUIStyle( InputPortLabel );
|
|
UnZoomedInputPortStyle.fontSize = (int)Constants.DefaultFontSize;
|
|
|
|
UnZoomedOutputPortPortStyle = new GUIStyle( OutputPortLabel );
|
|
UnZoomedOutputPortPortStyle.fontSize = (int)Constants.DefaultFontSize;
|
|
|
|
ObjectFieldThumb = new GUIStyle( (GUIStyle)"ObjectFieldThumb" );
|
|
ObjectFieldThumbOverlay = new GUIStyle( (GUIStyle)"ObjectFieldThumbOverlay" );
|
|
|
|
FloatIntPickerONOFF = new GUIStyle( "metimelabel" );
|
|
FloatIntPickerONOFF.padding.left = -2;
|
|
FloatIntPickerONOFF.margin = new RectOffset( 0 , 2 , 2 , 2 );
|
|
|
|
TooltipBox = new GUIStyle( (GUIStyle)"Tooltip" );
|
|
TooltipBox.richText = true;
|
|
|
|
MasterNodeOnTexture = AssetDatabase.LoadAssetAtPath<Texture2D>( AssetDatabase.GUIDToAssetPath( IOUtils.MasterNodeOnTextureGUID ) );
|
|
MasterNodeOffTexture = AssetDatabase.LoadAssetAtPath<Texture2D>( AssetDatabase.GUIDToAssetPath( IOUtils.MasterNodeOnTextureGUID ) );
|
|
|
|
GPUInstancedOnTexture = AssetDatabase.LoadAssetAtPath<Texture2D>( AssetDatabase.GUIDToAssetPath( IOUtils.GPUInstancedOnTextureGUID ) );
|
|
GPUInstancedOffTexture = AssetDatabase.LoadAssetAtPath<Texture2D>( AssetDatabase.GUIDToAssetPath( IOUtils.GPUInstancedOffTextureGUID ) );
|
|
|
|
CheckNullMaterials();
|
|
|
|
UsingProSkin = EditorGUIUtility.isProSkin;
|
|
FetchMenuItemStyles();
|
|
}
|
|
|
|
public static bool IsLoading
|
|
{
|
|
get { return CurrentWindow.OutsideGraph.IsLoading; }
|
|
}
|
|
|
|
public static void CheckNullMaterials()
|
|
{
|
|
if( LinearMaterial == null )
|
|
{
|
|
Shader linearShader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "e90ef6ea05743b84baf9549874c52e47" ) ); //linear previews
|
|
LinearMaterial = new Material( linearShader );
|
|
}
|
|
|
|
if( IntShader == null )
|
|
IntShader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "0f64d695b6ffacc469f2dd31432a232a" ) ); //int
|
|
if( FloatShader == null )
|
|
FloatShader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "d9ca47581ac157145bff6f72ac5dd73e" ) ); //ranged float
|
|
if( Vector2Shader == null )
|
|
Vector2Shader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "88b4191eb06084d4da85d1dd2f984085" ) ); //vector2
|
|
if( Vector3Shader == null )
|
|
Vector3Shader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "8a44d38f06246bf48944b3f314bc7920" ) ); //vector3
|
|
if( Vector4Shader == null )
|
|
Vector4Shader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "aac241d0e47a5a84fbd2edcd640788dc" ) ); //vector4
|
|
if( ColorShader == null )
|
|
ColorShader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "6cf365ccc7ae776488ae8960d6d134c3" ) ); //color node
|
|
if( MaskingShader == null )
|
|
MaskingShader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "9c34f18ebe2be3e48b201b748c73dec0" ) ); //masking shader
|
|
if( Texture2DShader == null )
|
|
Texture2DShader = AssetDatabase.LoadAssetAtPath<Shader>( AssetDatabase.GUIDToAssetPath( "13bd295c44d04e1419f20f792d331e33" ) ); //texture2d shader
|
|
}
|
|
|
|
private static void FetchMenuItemStyles()
|
|
{
|
|
ObjectFieldThumb = new GUIStyle( (GUIStyle)"ObjectFieldThumb" );
|
|
ObjectFieldThumbOverlay = new GUIStyle( (GUIStyle)"ObjectFieldThumbOverlay" );
|
|
MenuItemToggleStyle = new GUIStyle( (GUIStyle)"foldout" );
|
|
MenuItemEnableStyle = UsingProSkin ? new GUIStyle( (GUIStyle)"OL ToggleWhite" ) : new GUIStyle( (GUIStyle)"OL Toggle" );
|
|
MenuItemBackgroundStyle = new GUIStyle( (GUIStyle)"TE NodeBackground" );
|
|
MenuItemToolbarStyle = new GUIStyle( (GUIStyle)"toolbarbutton" ) { fixedHeight = 20 };
|
|
MenuItemInspectorDropdownStyle = new GUIStyle( (GUIStyle)"toolbardropdown" ) { fixedHeight = 20 };
|
|
MenuItemInspectorDropdownStyle.margin.bottom = 2;
|
|
|
|
|
|
InspectorPopdropdownStyle = new GUIStyle( GUI.skin.GetStyle( "PopupCurveDropdown" ) );
|
|
InspectorPopdropdownStyle.alignment = TextAnchor.MiddleRight;
|
|
InspectorPopdropdownStyle.border.bottom = 16;
|
|
|
|
InspectorPopdropdownFallback = new GUIStyle( InspectorPopdropdownStyle );
|
|
InspectorPopdropdownFallback.overflow = new RectOffset( 0 , -5 , 0 , 0 );
|
|
|
|
PlusStyle = ( EditorGUIUtility.isProSkin ) ? new GUIStyle( GetCustomStyle( CustomStyle.CustomExpressionAddItem ) ) : new GUIStyle( (GUIStyle)"OL Plus" );
|
|
PlusStyle.imagePosition = ImagePosition.ImageOnly;
|
|
PlusStyle.overflow = new RectOffset( -2 , 0 , -4 , 0 );
|
|
|
|
MinusStyle = ( EditorGUIUtility.isProSkin ) ? new GUIStyle( GetCustomStyle( CustomStyle.CustomExpressionRemoveItem ) ) : new GUIStyle( (GUIStyle)"OL Minus" );
|
|
MinusStyle.contentOffset = Vector2.zero;
|
|
MinusStyle.imagePosition = ImagePosition.ImageOnly;
|
|
MinusStyle.overflow = new RectOffset( -2 , 0 , -4 , 0 );
|
|
|
|
ToolbarSearchTextfield = new GUIStyle( (GUIStyle)"ToolbarSeachTextField" );
|
|
ToolbarSearchCancelButton = new GUIStyle( (GUIStyle)"ToolbarSeachCancelButton" );
|
|
}
|
|
|
|
public static void UpdateMainSkin( DrawInfo drawInfo )
|
|
{
|
|
CurrentHeaderHeight = HeaderMaxHeight * drawInfo.InvertedZoom;
|
|
ScaledPortsDelta = drawInfo.InvertedZoom * PortsDelta;
|
|
MainSkin.textField.fontSize = (int)( Constants.TextFieldFontSize * drawInfo.InvertedZoom );
|
|
MainSkin.label.fontSize = (int)( Constants.DefaultFontSize * drawInfo.InvertedZoom );
|
|
|
|
MainSkin.customStyles[ (int)CustomStyle.NodeTitle ].fontSize = (int)( Constants.DefaultTitleFontSize * drawInfo.InvertedZoom );
|
|
MainSkin.customStyles[ (int)CustomStyle.PropertyValuesTitle ].fontSize = (int)( Constants.PropertiesTitleFontSize * drawInfo.InvertedZoom );
|
|
|
|
InputPortLabel.fontSize = (int)( Constants.DefaultFontSize * drawInfo.InvertedZoom );
|
|
OutputPortLabel.fontSize = (int)( Constants.DefaultFontSize * drawInfo.InvertedZoom );
|
|
CommentaryTitle.fontSize = (int)( Constants.DefaultFontSize * drawInfo.InvertedZoom );
|
|
StickyNoteText.fontSize = (int)( Constants.DefaultFontSize * drawInfo.InvertedZoom );
|
|
|
|
RangedFloatSliderStyle.fixedHeight = 18 * drawInfo.InvertedZoom;
|
|
RangedFloatSliderThumbStyle.fixedHeight = 12 * drawInfo.InvertedZoom;
|
|
RangedFloatSliderThumbStyle.fixedWidth = 10 * drawInfo.InvertedZoom;
|
|
RangedFloatSliderThumbStyle.overflow.left = (int)( 1 * drawInfo.InvertedZoom );
|
|
RangedFloatSliderThumbStyle.overflow.right = (int)( 1 * drawInfo.InvertedZoom );
|
|
RangedFloatSliderThumbStyle.overflow.top = (int)( -4 * drawInfo.InvertedZoom );
|
|
RangedFloatSliderThumbStyle.overflow.bottom = (int)( 4 * drawInfo.InvertedZoom );
|
|
|
|
SwitchNodePopUp.fixedHeight = SwitchFixedHeight * drawInfo.InvertedZoom;
|
|
|
|
SwitchNodePopUp.border.left = (int)( SwitchNodeBorder.left * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.border.right = (int)( SwitchNodeBorder.right * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.border.top = (int)( SwitchNodeBorder.top * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.border.bottom = (int)( SwitchNodeBorder.bottom * drawInfo.InvertedZoom );
|
|
|
|
SwitchNodePopUp.margin.left = (int)( SwitchNodeMargin.left * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.margin.right = (int)( SwitchNodeMargin.right * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.margin.top = (int)( SwitchNodeMargin.top * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.margin.bottom = (int)( SwitchNodeMargin.bottom * drawInfo.InvertedZoom );
|
|
|
|
SwitchNodePopUp.overflow.left = (int)( SwitchNodeOverflow.left * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.overflow.right = (int)( SwitchNodeOverflow.right * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.overflow.top = (int)( SwitchNodeOverflow.top * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.overflow.bottom = (int)( SwitchNodeOverflow.bottom * drawInfo.InvertedZoom );
|
|
|
|
SwitchNodePopUp.padding.left = (int)( SwitchNodePadding.left * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.padding.right = (int)( SwitchNodePadding.right * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.padding.top = (int)( SwitchNodePadding.top * drawInfo.InvertedZoom );
|
|
SwitchNodePopUp.padding.bottom = (int)( SwitchNodePadding.bottom * drawInfo.InvertedZoom );
|
|
|
|
SwitchNodePopUp.fontSize = (int)( SwitchFontSize * drawInfo.InvertedZoom );
|
|
|
|
BoldErrorStyle.fontSize = (int)( 12 * drawInfo.InvertedZoom );
|
|
BoldWarningStyle.fontSize = (int)( 12 * drawInfo.InvertedZoom );
|
|
BoldInfoStyle.fontSize = (int)( 12 * drawInfo.InvertedZoom );
|
|
|
|
PropertyPopUp.fixedHeight = Constants.PropertyPickerHeight * drawInfo.InvertedZoom;
|
|
PropertyPopUp.fixedWidth = Constants.PropertyPickerWidth * drawInfo.InvertedZoom;
|
|
if( UsingProSkin != EditorGUIUtility.isProSkin )
|
|
{
|
|
UsingProSkin = EditorGUIUtility.isProSkin;
|
|
FetchMenuItemStyles();
|
|
}
|
|
|
|
GraphDropDown.padding.left = (int)( 2 * drawInfo.InvertedZoom + 2 );
|
|
GraphDropDown.padding.right = (int)( 20 * drawInfo.InvertedZoom );
|
|
GraphDropDown.fontSize = (int)( 10 * drawInfo.InvertedZoom );
|
|
|
|
PreviewExpander.fixedHeight = Constants.PreviewExpanderHeight * drawInfo.InvertedZoom;
|
|
PreviewExpander.fixedWidth = Constants.PreviewExpanderWidth * drawInfo.InvertedZoom;
|
|
|
|
PreviewCollapser.fixedHeight = Constants.PreviewExpanderHeight * drawInfo.InvertedZoom;
|
|
PreviewCollapser.fixedWidth = Constants.PreviewExpanderWidth * drawInfo.InvertedZoom;
|
|
|
|
MainSkin.customStyles[ (int)CustomStyle.SamplerButton ].fontSize = (int)( 9 * drawInfo.InvertedZoom );
|
|
ObjectFieldThumbOverlay.fontSize = (int)( 9 * drawInfo.InvertedZoom );
|
|
MiniButtonTopLeft.fontSize = (int)( 9 * drawInfo.InvertedZoom );
|
|
MiniButtonTopMid.fontSize = (int)( 9 * drawInfo.InvertedZoom );
|
|
MiniButtonTopRight.fontSize = (int)( 9 * drawInfo.InvertedZoom );
|
|
|
|
MiniObjectFieldThumbOverlay.fontSize = (int)( 7 * drawInfo.InvertedZoom );
|
|
MiniSamplerButton.fontSize = (int)( 8 * drawInfo.InvertedZoom );
|
|
|
|
InternalDataOnPort.fontSize = (int)( 8 * drawInfo.InvertedZoom );
|
|
ToolbarMainTitle.padding.left = 0;
|
|
ToolbarMainTitle.padding.right = 0;
|
|
|
|
CheckNullMaterials();
|
|
}
|
|
|
|
public static void CacheLabelVars()
|
|
{
|
|
m_alignment = GUI.skin.label.alignment;
|
|
m_clipping = GUI.skin.label.clipping;
|
|
m_wordWrap = GUI.skin.label.wordWrap;
|
|
m_fontSize = GUI.skin.label.fontSize;
|
|
m_fontStyle = GUI.skin.label.fontStyle;
|
|
m_fontColor = GUI.skin.label.normal.textColor;
|
|
}
|
|
|
|
public static void RestoreLabelVars()
|
|
{
|
|
GUI.skin.label.alignment = m_alignment;
|
|
GUI.skin.label.clipping = m_clipping;
|
|
GUI.skin.label.wordWrap = m_wordWrap;
|
|
GUI.skin.label.fontSize = m_fontSize;
|
|
GUI.skin.label.fontStyle = m_fontStyle;
|
|
GUI.skin.label.normal.textColor = m_fontColor;
|
|
}
|
|
|
|
public static string GetTooltipForToolButton( ToolButtonType toolButtonType , int state ) { return m_toolButtonTooltips[ toolButtonType ][ state ]; }
|
|
|
|
public static string KeyCodeToString( KeyCode keyCode )
|
|
{
|
|
if( m_keycodeToString.ContainsKey( keyCode ) )
|
|
return m_keycodeToString[ keyCode ];
|
|
|
|
return keyCode.ToString();
|
|
}
|
|
|
|
public static string TextureTypeToCgType( TextureType type ) { return m_textureTypeToCgType[ type ]; }
|
|
|
|
public static string QualifierToCg( VariableQualifiers qualifier )
|
|
{
|
|
return m_qualifierToCg[ qualifier ];
|
|
}
|
|
|
|
public static string WirePortToCgType( WirePortDataType type )
|
|
{
|
|
if( type == WirePortDataType.OBJECT )
|
|
return string.Empty;
|
|
|
|
return m_wirePortToCgType[ type ];
|
|
}
|
|
|
|
public static string FinalPrecisionWirePortToCgType( PrecisionType precisionType , WirePortDataType type )
|
|
{
|
|
return PrecisionWirePortToCgType( precisionType , type );
|
|
}
|
|
|
|
public static string PrecisionWirePortToCgType( PrecisionType precisionType , WirePortDataType type )
|
|
{
|
|
if( type == WirePortDataType.OBJECT )
|
|
return string.Empty;
|
|
|
|
if( type == WirePortDataType.INT )
|
|
return m_wirePortToCgType[ type ];
|
|
|
|
if( type == WirePortDataType.UINT )
|
|
return m_wirePortToCgType[ type ];
|
|
|
|
if( type == WirePortDataType.UINT4 )
|
|
return m_wirePortToCgType[ type ];
|
|
|
|
return string.Format( m_precisionWirePortToCgType[ type ] , m_precisionTypeToCg[ precisionType ] );
|
|
}
|
|
|
|
public static string PrecisionWirePortToTypeValue( PrecisionType precisionType , WirePortDataType type , string varName/*, bool isSRP, bool samplingMacro*/ )
|
|
{
|
|
string result = string.Empty;
|
|
string varType = string.Empty;
|
|
if( type == WirePortDataType.OBJECT )
|
|
varType = string.Empty;
|
|
|
|
if( type == WirePortDataType.INT )
|
|
varType = m_wirePortToCgType[ type ];
|
|
|
|
if( type == WirePortDataType.UINT )
|
|
varType = m_wirePortToCgType[ type ];
|
|
|
|
switch( type )
|
|
{
|
|
default:
|
|
case WirePortDataType.OBJECT:
|
|
case WirePortDataType.SAMPLERSTATE:
|
|
case WirePortDataType.FLOAT:
|
|
case WirePortDataType.FLOAT2:
|
|
case WirePortDataType.FLOAT3:
|
|
case WirePortDataType.FLOAT4:
|
|
case WirePortDataType.FLOAT3x3:
|
|
case WirePortDataType.FLOAT4x4:
|
|
case WirePortDataType.COLOR:
|
|
case WirePortDataType.UINT:
|
|
case WirePortDataType.INT:
|
|
case WirePortDataType.SAMPLER1D:
|
|
varType = string.Format( m_precisionWirePortToCgType[ type ] , m_precisionTypeToCg[ precisionType ] );
|
|
result = varType + " " + varName;
|
|
break;
|
|
case WirePortDataType.SAMPLER2D:
|
|
case WirePortDataType.SAMPLER3D:
|
|
case WirePortDataType.SAMPLERCUBE:
|
|
case WirePortDataType.SAMPLER2DARRAY:
|
|
ParentGraph outsideGraph = UIUtils.CurrentWindow.OutsideGraph;
|
|
if( outsideGraph.SamplingMacros /*&& !outsideGraph.IsStandardSurface*/ )
|
|
{
|
|
if( outsideGraph.IsSRP )
|
|
varType = string.Format( m_precisionWirePortToSRPMacroType[ type ] , m_precisionTypeToCg[ precisionType ] );
|
|
else
|
|
varType = string.Format( m_precisionWirePortToStandardMacroType[ type ] , m_precisionTypeToCg[ precisionType ] );
|
|
result = varType + varName + ")";
|
|
}
|
|
else
|
|
{
|
|
varType = string.Format( m_precisionWirePortToCgType[ type ] , m_precisionTypeToCg[ precisionType ] );
|
|
result = varType + " " + varName;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetAutoSwizzle( WirePortDataType type )
|
|
{
|
|
return m_autoSwizzle[ type ];
|
|
}
|
|
|
|
public static Color GetColorForDataType( WirePortDataType dataType , bool monochromeMode = true , bool isInput = true )
|
|
{
|
|
if( monochromeMode )
|
|
{
|
|
return isInput ? m_dataTypeToColorMonoMode[ 0 ] : m_dataTypeToColorMonoMode[ 1 ];
|
|
}
|
|
else
|
|
{
|
|
if( m_dataTypeToColor.ContainsKey( dataType ) )
|
|
return m_dataTypeToColor[ dataType ];
|
|
}
|
|
return m_dataTypeToColor[ WirePortDataType.OBJECT ];
|
|
}
|
|
|
|
public static bool IsValidType( WirePortDataType type )
|
|
{
|
|
switch( type )
|
|
{
|
|
case WirePortDataType.OBJECT:
|
|
case WirePortDataType.SAMPLERSTATE:
|
|
case WirePortDataType.FLOAT:
|
|
case WirePortDataType.FLOAT2:
|
|
case WirePortDataType.FLOAT3:
|
|
case WirePortDataType.FLOAT4:
|
|
case WirePortDataType.FLOAT3x3:
|
|
case WirePortDataType.FLOAT4x4:
|
|
case WirePortDataType.COLOR:
|
|
case WirePortDataType.INT:
|
|
case WirePortDataType.SAMPLER1D:
|
|
case WirePortDataType.SAMPLER2D:
|
|
case WirePortDataType.SAMPLER3D:
|
|
case WirePortDataType.SAMPLERCUBE:
|
|
case WirePortDataType.SAMPLER2DARRAY:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
public static string GetNameForDataType( WirePortDataType dataType ) { return m_dataTypeToName[ dataType ]; }
|
|
|
|
public static string GetInputDeclarationFromType( PrecisionType precision , SurfaceInputs inputType )
|
|
{
|
|
string precisionStr = m_precisionTypeToCg[ precision ];
|
|
return string.Format( m_inputTypeDeclaration[ inputType ] , precisionStr );
|
|
}
|
|
|
|
public static string GetInputValueFromType( SurfaceInputs inputType ) { return m_inputTypeName[ inputType ]; }
|
|
private static string CreateLocalValueName( PrecisionType precision , WirePortDataType dataType , string localOutputValue , string value ) { return string.Format( Constants.LocalValueDecWithoutIdent , PrecisionWirePortToCgType( precision , dataType ) , localOutputValue , value ); }
|
|
|
|
public static string CastPortType( ref MasterNodeDataCollector dataCollector , PrecisionType nodePrecision , NodeCastInfo castInfo , object value , WirePortDataType oldType , WirePortDataType newType , string parameterName = null )
|
|
{
|
|
if( oldType == newType || newType == WirePortDataType.OBJECT )
|
|
{
|
|
return ( parameterName != null ) ? parameterName : value.ToString();
|
|
}
|
|
|
|
PrecisionType currentPrecision = nodePrecision;
|
|
string precisionStr = m_precisionTypeToCg[ currentPrecision ];
|
|
string newTypeStr = m_wirePortToCgType[ newType ];
|
|
newTypeStr = m_textInfo.ToTitleCase( newTypeStr );
|
|
int castId = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation ) ? dataCollector.AvailableVertexTempId : dataCollector.AvailableFragTempId;
|
|
string localVarName = "temp_cast_" + castId;//m_wirePortToCgType[ oldType ] + "To" + newTypeStr + "_" + castInfo.ToString();
|
|
string result = string.Empty;
|
|
bool useRealValue = ( parameterName == null );
|
|
|
|
switch( oldType )
|
|
{
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? value.ToString() : parameterName; break;
|
|
case WirePortDataType.FLOAT2:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , string.Format( Constants.CastHelper , ( ( useRealValue ) ? value.ToString() : parameterName ) , "xx" ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , string.Format( Constants.CastHelper , ( ( useRealValue ) ? value.ToString() : parameterName ) , "xxx" ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.COLOR:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , string.Format( Constants.CastHelper , ( ( useRealValue ) ? value.ToString() : parameterName ) , "xxxx" ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , string.Format( Constants.CastHelper , ( ( useRealValue ) ? value.ToString() : parameterName ) , "xxxx" ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3x3:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4x4:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.INT:
|
|
{
|
|
result = ( useRealValue ) ? ( (int)value ).ToString() : "(int)" + parameterName;
|
|
}
|
|
break;
|
|
case WirePortDataType.UINT:
|
|
{
|
|
result = ( useRealValue ) ? ( (int)value ).ToString() : "(uint)" + parameterName;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT2:
|
|
{
|
|
Vector2 vecVal = useRealValue ? (Vector2)value : Vector2.zero;
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? precisionStr + "2( " + vecVal.x + " , " + vecVal.y + " )" : parameterName; break;
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
result = ( useRealValue ) ? vecVal.x.ToString() : parameterName + ".x";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "3( " + vecVal.x + " , " + vecVal.y + " , " + " 0.0 )" : precisionStr + "3( " + parameterName + " , 0.0 )";
|
|
}
|
|
break;
|
|
case WirePortDataType.COLOR:
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "4( " + vecVal.x + " , " + vecVal.y + " , " + " 0.0 , 0.0 )" : precisionStr + "4( " + parameterName + ", 0.0 , 0.0 )";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3:
|
|
{
|
|
Vector3 vecVal = useRealValue ? (Vector3)value : Vector3.zero;
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? precisionStr + "3( " + vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " )" : parameterName; break;
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
result = ( useRealValue ) ? vecVal.x.ToString() : parameterName + ".x";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT2:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "2( " + vecVal.x + " , " + vecVal.y + " )" : parameterName + ".xy";
|
|
}
|
|
break;
|
|
case WirePortDataType.COLOR:
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "4( " + vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " , 0.0 )" : precisionStr + "4( " + parameterName + " , 0.0 )";
|
|
}
|
|
break;
|
|
//case WirePortDataType.FLOAT3x3:
|
|
//{
|
|
// if ( useRealValue )
|
|
// {
|
|
// result = precisionStr + "3x3( " + vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " , " +
|
|
// vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " , " +
|
|
// vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " )";
|
|
// }
|
|
// else
|
|
// {
|
|
// string localVal = CreateLocalValueName( currentPrecision, newType, localVarName, parameterName );
|
|
// CurrentDataCollector.AddToLocalVariables( portCategory, -1, localVal );
|
|
// result = precisionStr + "3x3( " + localVarName + ".x , " + localVarName + ".y , " + localVarName + ".x , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".y , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z )";
|
|
// }
|
|
//}
|
|
//break;
|
|
//case WirePortDataType.FLOAT4x4:
|
|
//{
|
|
// if ( useRealValue )
|
|
// {
|
|
// result = precisionStr + "4x4( " + vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , 0 , " +
|
|
// vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , 0 , " +
|
|
// vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , 0 , " +
|
|
// vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , 0 )";
|
|
// }
|
|
// else
|
|
// {
|
|
// string localVal = CreateLocalValueName( currentPrecision, newType, localVarName, parameterName );
|
|
// CurrentDataCollector.AddToLocalVariables( portCategory, -1, localVal );
|
|
// result = precisionStr + "4x4( " + localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , 0 , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , 0 , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , 0 , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , 0 )";
|
|
// }
|
|
//}
|
|
//break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
Vector4 vecVal = useRealValue ? (Vector4)value : Vector4.zero;
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? precisionStr + "4( " + vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " , " + vecVal.w + " )" : parameterName; break;
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
result = ( useRealValue ) ? vecVal.x.ToString() : parameterName + ".x";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT2:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "2( " + vecVal.x + " , " + vecVal.y + " )" : parameterName + ".xy";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "3( " + vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " )" : parameterName + ".xyz";
|
|
}
|
|
break;
|
|
//case WirePortDataType.FLOAT4x4:
|
|
//{
|
|
// if ( useRealValue )
|
|
// {
|
|
// result = precisionStr + "4x4( " + vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , " + vecVal + ".w , " +
|
|
// vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , " + vecVal + ".w , " +
|
|
// vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , " + vecVal + ".w , " +
|
|
// vecVal + ".x , " + vecVal + ".y , " + vecVal + ".z , " + vecVal + ".w )";
|
|
// }
|
|
// else
|
|
// {
|
|
// string localVal = CreateLocalValueName( currentPrecision, newType, localVarName, parameterName );
|
|
// CurrentDataCollector.AddToLocalVariables( portCategory, -1, localVal );
|
|
// result = precisionStr + "4x4( " + localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w )";
|
|
// }
|
|
//}
|
|
//break;
|
|
case WirePortDataType.COLOR:
|
|
{
|
|
result = useRealValue ? precisionStr + "4( " + vecVal.x + " , " + vecVal.y + " , " + vecVal.z + " , " + vecVal.w + " )" : parameterName;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3x3:
|
|
{
|
|
//Matrix4x4 matrixVal = useRealValue ? ( Matrix4x4 ) value : Matrix4x4.identity;
|
|
//switch ( newType )
|
|
//{
|
|
// case WirePortDataType.OBJECT:
|
|
// case WirePortDataType.FLOAT4x4:
|
|
// {
|
|
// result = ( useRealValue ) ? precisionStr + "4x4(" + matrixVal.m00 + " , " + matrixVal.m01 + " , " + matrixVal.m02 + " , " + matrixVal.m03 + " , " +
|
|
// matrixVal.m10 + " , " + matrixVal.m11 + " , " + matrixVal.m12 + " , " + matrixVal.m10 + " , " +
|
|
// matrixVal.m20 + " , " + matrixVal.m21 + " , " + matrixVal.m22 + " , " + matrixVal.m20 + " , " +
|
|
// matrixVal.m30 + " , " + matrixVal.m31 + " , " + matrixVal.m32 + " , " + matrixVal.m30 + " )" : precisionStr + "4x4(" + parameterName + ")";
|
|
// }
|
|
// break;
|
|
//}
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4x4:
|
|
{
|
|
Matrix4x4 matrixVal = useRealValue ? (Matrix4x4)value : Matrix4x4.identity;
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "4x4(" + matrixVal.m00 + " , " + matrixVal.m01 + " , " + matrixVal.m02 + " , " + matrixVal.m03 + " , " +
|
|
matrixVal.m10 + " , " + matrixVal.m11 + " , " + matrixVal.m12 + " , " + matrixVal.m10 + " , " +
|
|
matrixVal.m20 + " , " + matrixVal.m21 + " , " + matrixVal.m22 + " , " + matrixVal.m20 + " , " +
|
|
matrixVal.m30 + " , " + matrixVal.m31 + " , " + matrixVal.m32 + " , " + matrixVal.m30 + " )" : parameterName;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.COLOR:
|
|
{
|
|
Color colorValue = ( useRealValue ) ? (Color)value : Color.black;
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? precisionStr + "4( " + colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " , " + colorValue.a + " )" : parameterName; break;
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
result = ( useRealValue ) ? colorValue.r.ToString() : parameterName + ".r";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT2:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "2( " + colorValue.r + " , " + colorValue.g + " )" : parameterName + ".rg";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3:
|
|
{
|
|
result = ( useRealValue ) ? precisionStr + "3( " + colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " )" : parameterName + ".rgb";
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
result = useRealValue ? precisionStr + "4( " + colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " , " + colorValue.a + " )" : parameterName;
|
|
}
|
|
break;
|
|
//case WirePortDataType.FLOAT4x4:
|
|
//{
|
|
// if ( useRealValue )
|
|
// {
|
|
// result = precisionStr + "4x4( " + colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " , " + colorValue.a + " , " +
|
|
// colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " , " + colorValue.a + " , " +
|
|
// colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " , " + colorValue.a + " , " +
|
|
// colorValue.r + " , " + colorValue.g + " , " + colorValue.b + " , " + colorValue.a + " )";
|
|
// }
|
|
// else
|
|
// {
|
|
// string localVal = CreateLocalValueName( currentPrecision, newType, localVarName, parameterName );
|
|
// CurrentDataCollector.AddToLocalVariables( portCategory, -1, localVal );
|
|
|
|
// result = precisionStr + "4x4( " + localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w , " +
|
|
// localVarName + ".x , " + localVarName + ".y , " + localVarName + ".z , " + localVarName + ".w )";
|
|
// }
|
|
//}
|
|
//break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.INT:
|
|
{
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? value.ToString() : parameterName; break;
|
|
case WirePortDataType.FLOAT2:
|
|
case WirePortDataType.FLOAT3:
|
|
case WirePortDataType.COLOR:
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3x3:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , oldType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4x4:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , oldType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
result = ( useRealValue ) ? ( (int)value ).ToString() : "(float)" + parameterName;
|
|
}
|
|
break;
|
|
case WirePortDataType.UINT:
|
|
{
|
|
result = ( useRealValue ) ? ( (int)value ).ToString() : "(uint)" + parameterName;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case WirePortDataType.UINT:
|
|
{
|
|
switch( newType )
|
|
{
|
|
case WirePortDataType.OBJECT: result = useRealValue ? value.ToString() : parameterName; break;
|
|
case WirePortDataType.FLOAT2:
|
|
case WirePortDataType.FLOAT3:
|
|
case WirePortDataType.COLOR:
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , newType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3x3:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , oldType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4x4:
|
|
{
|
|
string localVal = CreateLocalValueName( currentPrecision , oldType , localVarName , ( ( useRealValue ) ? value.ToString() : parameterName ) );
|
|
dataCollector.AddToLocalVariables( dataCollector.PortCategory , -1 , localVal );
|
|
result = localVarName;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
result = ( useRealValue ) ? ( (int)value ).ToString() : "(float)" + parameterName;
|
|
}
|
|
break;
|
|
case WirePortDataType.INT:
|
|
{
|
|
result = ( useRealValue ) ? ( (int)value ).ToString() : "(int)" + parameterName;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if( result.Equals( string.Empty ) )
|
|
{
|
|
result = "0";
|
|
string warningStr = string.Format( "Unable to cast from {0} to {1}. Generating dummy data ( {2} )" , oldType , newType , result );
|
|
|
|
if( oldType == WirePortDataType.SAMPLER1D || oldType == WirePortDataType.SAMPLER2D || oldType == WirePortDataType.SAMPLER3D || oldType == WirePortDataType.SAMPLERCUBE || oldType == WirePortDataType.SAMPLER2DARRAY )
|
|
{
|
|
warningStr = string.Format( "Unable to cast from {0} to {1}. You might want to use a Texture Sample node and connect it to the 'Tex' port. Generating dummy data ( {2} )" , oldType , newType , result );
|
|
}
|
|
ShowMessage( warningStr , MessageSeverity.Warning );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool CanCast( WirePortDataType from , WirePortDataType to )
|
|
{
|
|
if( from == WirePortDataType.OBJECT || to == WirePortDataType.OBJECT || from == to )
|
|
return true;
|
|
|
|
switch( from )
|
|
{
|
|
case WirePortDataType.FLOAT:
|
|
{
|
|
if( to == WirePortDataType.INT )
|
|
return true;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT2:
|
|
{
|
|
return false;
|
|
}
|
|
case WirePortDataType.FLOAT3:
|
|
{
|
|
if( to == WirePortDataType.COLOR ||
|
|
to == WirePortDataType.FLOAT4 )
|
|
return true;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4:
|
|
{
|
|
if( to == WirePortDataType.FLOAT3 ||
|
|
to == WirePortDataType.COLOR )
|
|
return true;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT3x3:
|
|
{
|
|
if( to == WirePortDataType.FLOAT4x4 )
|
|
return true;
|
|
}
|
|
break;
|
|
case WirePortDataType.FLOAT4x4:
|
|
{
|
|
if( to == WirePortDataType.FLOAT3x3 )
|
|
return true;
|
|
}
|
|
break;
|
|
case WirePortDataType.COLOR:
|
|
{
|
|
if( to == WirePortDataType.FLOAT3 ||
|
|
to == WirePortDataType.FLOAT4 )
|
|
return true;
|
|
|
|
}
|
|
break;
|
|
case WirePortDataType.INT:
|
|
{
|
|
if( to == WirePortDataType.FLOAT )
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static int GetChannelsAmount( WirePortDataType type )
|
|
{
|
|
switch( type )
|
|
{
|
|
case WirePortDataType.OBJECT: return 0;
|
|
case WirePortDataType.FLOAT: return 1;
|
|
case WirePortDataType.FLOAT2: return 2;
|
|
case WirePortDataType.FLOAT3: return 3;
|
|
case WirePortDataType.FLOAT4: return 4;
|
|
case WirePortDataType.FLOAT3x3: return 9;
|
|
case WirePortDataType.FLOAT4x4: return 16;
|
|
case WirePortDataType.COLOR: return 4;
|
|
case WirePortDataType.INT: return 1;
|
|
case WirePortDataType.UINT: return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static WirePortDataType GetWireTypeForChannelAmount( int channelAmount )
|
|
{
|
|
switch( channelAmount )
|
|
{
|
|
case 1: return WirePortDataType.FLOAT;
|
|
case 2: return WirePortDataType.FLOAT2;
|
|
case 3: return WirePortDataType.FLOAT3;
|
|
case 4: return WirePortDataType.FLOAT4;
|
|
case 9: return WirePortDataType.FLOAT3x3;
|
|
case 16: return WirePortDataType.FLOAT4x4;
|
|
}
|
|
return WirePortDataType.FLOAT;
|
|
}
|
|
|
|
public static string GenerateUniformName( bool excludeUniformKeyword , WirePortDataType dataType , string dataName )
|
|
{
|
|
return GenerateUniformName( excludeUniformKeyword , WirePortToCgType( dataType ) , dataName );
|
|
}
|
|
|
|
public static string GenerateUniformName( bool excludeUniformKeyword , string dataType , string dataName )
|
|
{
|
|
int index = excludeUniformKeyword ? 1 : 0;
|
|
return string.Format( Constants.UniformDec[ index ] , dataType , dataName );
|
|
}
|
|
|
|
public static string GeneratePropertyName( string name , PropertyType propertyType , bool forceUnderscore = false )
|
|
{
|
|
if( string.IsNullOrEmpty( name ) )
|
|
return name;
|
|
|
|
name = RemoveInvalidCharacters( name );
|
|
if( propertyType != PropertyType.Global || forceUnderscore )
|
|
{
|
|
if( name[ 0 ] != '_' )
|
|
{
|
|
name = '_' + name;
|
|
}
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
public static string UrlReplaceInvalidStrings( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.UrlReplacementStringValuesLen ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.UrlReplacementStringValues[ i , 0 ] , Constants.UrlReplacementStringValues[ i , 1 ] );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string ReplaceInvalidStrings( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.ReplacementStringValuesLen ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.ReplacementStringValues[ i , 0 ] , Constants.ReplacementStringValues[ i , 1 ] );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string RemoveWikiInvalidCharacters( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.WikiInvalidChars.Length ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.WikiInvalidChars[ i ] , string.Empty );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string RemoveInvalidEnumCharacters( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.EnumInvalidChars.Length ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.EnumInvalidChars[ i ] , string.Empty );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string RemoveInvalidAttrCharacters( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.AttrInvalidChars.Length ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.AttrInvalidChars[ i ] , string.Empty );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string RemoveHeaderAttrCharacters( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.AttrInvalidChars.Length ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.HeaderInvalidChars[ i ] , string.Empty );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string RemoveInvalidCharacters( string originalString )
|
|
{
|
|
for( int i = 0 ; i < Constants.OverallInvalidChars.Length ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.OverallInvalidChars[ i ] , string.Empty );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static string RemoveShaderInvalidCharacters( string originalString )
|
|
{
|
|
originalString = originalString.Replace( '\\' , '/' );
|
|
for( int i = 0 ; i < Constants.ShaderInvalidChars.Length ; i++ )
|
|
{
|
|
originalString = originalString.Replace( Constants.ShaderInvalidChars[ i ] , string.Empty );
|
|
}
|
|
return originalString;
|
|
}
|
|
|
|
public static bool IsUnityNativeShader( Shader shader )
|
|
{
|
|
string pathName = AssetDatabase.GetAssetPath( shader );
|
|
|
|
if( pathName.Contains( "unity_builtin_extra" ) ||
|
|
pathName.Contains( "unity default resources" ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
public static bool IsUnityNativeShader( string path ) { return m_unityNativeShaderPaths.ContainsKey( path ); }
|
|
|
|
public static string GetComponentForPosition( int pos , WirePortDataType type , bool addDot = false )
|
|
{
|
|
string result = addDot ? "." : string.Empty;
|
|
switch( pos )
|
|
{
|
|
case 0:
|
|
{
|
|
return ( ( type == WirePortDataType.COLOR ) ? ( result + "r" ) : ( result + "x" ) );
|
|
}
|
|
case 1:
|
|
{
|
|
return ( ( type == WirePortDataType.COLOR ) ? ( result + "g" ) : ( result + "y" ) );
|
|
}
|
|
case 2:
|
|
{
|
|
return ( ( type == WirePortDataType.COLOR ) ? ( result + "b" ) : ( result + "z" ) );
|
|
}
|
|
case 3:
|
|
{
|
|
return ( ( type == WirePortDataType.COLOR ) ? ( result + "a" ) : ( result + "w" ) );
|
|
}
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
public static string InvalidParameter( ParentNode node )
|
|
{
|
|
ShowMessage( node.UniqueId , "Invalid entrance type on node" + node , MessageSeverity.Error );
|
|
return "0";
|
|
}
|
|
|
|
public static string NoConnection( ParentNode node )
|
|
{
|
|
ShowMessage( node.UniqueId , "No Input connection on node" + node , MessageSeverity.Error );
|
|
return "0";
|
|
}
|
|
|
|
public static string UnknownError( ParentNode node )
|
|
{
|
|
ShowMessage( node.UniqueId , "Unknown error on node" + node , MessageSeverity.Error );
|
|
return "0";
|
|
}
|
|
|
|
public static string GetTex2DProperty( string name , TexturePropertyValues defaultValue ) { return name + "(\"" + name + "\", 2D) = \"" + defaultValue + "\" {}"; }
|
|
public static string AddBrackets( string value ) { return "( " + value + " )"; }
|
|
public static Color GetColorFromWireStatus( WireStatus status ) { return m_wireStatusToColor[ status ]; }
|
|
public static bool HasColorCategory( string category ) { return m_nodeCategoryToColor.ContainsKey( category ); }
|
|
public static void AddColorCategory( string category , Color color )
|
|
{
|
|
m_nodeCategoryToColor.Add( category , color );
|
|
}
|
|
|
|
public static Color AddColorCategory( string category , string hexColor )
|
|
{
|
|
try
|
|
{
|
|
Color color = new Color();
|
|
ColorUtility.TryParseHtmlString( hexColor , out color );
|
|
m_nodeCategoryToColor.Add( category , color );
|
|
return color;
|
|
}
|
|
catch( System.Exception e )
|
|
{
|
|
Debug.LogException( e );
|
|
}
|
|
return m_nodeCategoryToColor[ "Default" ];
|
|
}
|
|
|
|
public static Color GetColorFromCategory( string category )
|
|
{
|
|
if( m_nodeCategoryToColor.ContainsKey( category ) )
|
|
return m_nodeCategoryToColor[ category ];
|
|
|
|
|
|
if( DebugConsoleWindow.DeveloperMode )
|
|
Debug.LogWarning( category + " category does not contain an associated color" );
|
|
|
|
return m_nodeCategoryToColor[ "Default" ];
|
|
}
|
|
|
|
public static string LatestOpenedFolder
|
|
{
|
|
get { return m_latestOpenedFolder; }
|
|
set { m_latestOpenedFolder = value; }
|
|
}
|
|
|
|
public static void ActivatePreviews( bool value )
|
|
{
|
|
int count = IOUtils.AllOpenedWindows.Count;
|
|
for( int i = 0 ; i < count ; i++ )
|
|
{
|
|
IOUtils.AllOpenedWindows[ i ].ActivatePreviews( value );
|
|
}
|
|
}
|
|
|
|
public static Shader CreateNewUnlit()
|
|
{
|
|
if( CurrentWindow == null )
|
|
return null;
|
|
|
|
string shaderName;
|
|
string pathName;
|
|
Shader newShader = null;
|
|
IOUtils.GetShaderName( out shaderName , out pathName , "MyUnlitShader" , m_latestOpenedFolder );
|
|
if( !System.String.IsNullOrEmpty( shaderName ) && !System.String.IsNullOrEmpty( pathName ) )
|
|
{
|
|
CurrentWindow.CreateNewGraph( shaderName );
|
|
CurrentWindow.PreMadeShadersInstance.FlatColorSequence.Execute();
|
|
|
|
CurrentWindow.CurrentGraph.CurrentMasterNode.SetName( shaderName );
|
|
newShader = CurrentWindow.CurrentGraph.FireMasterNode( pathName , true );
|
|
AssetDatabase.Refresh();
|
|
}
|
|
return newShader;
|
|
}
|
|
|
|
public static Shader CreateNewEmpty( string customPath = null , string customShaderName = null )
|
|
{
|
|
if( CurrentWindow == null )
|
|
return null;
|
|
|
|
string shaderName;
|
|
string pathName;
|
|
Shader newShader = null;
|
|
|
|
|
|
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 ) ) , "" );
|
|
}
|
|
|
|
|
|
if( string.IsNullOrEmpty( customPath ) )
|
|
{
|
|
IOUtils.GetShaderName( out shaderName , out pathName , Constants.DefaultShaderName , m_latestOpenedFolder );
|
|
}
|
|
else
|
|
{
|
|
pathName = customPath;
|
|
if( string.IsNullOrEmpty( customShaderName ) )
|
|
{
|
|
shaderName = Constants.DefaultShaderName;
|
|
int indexOfAssets = pathName.IndexOf( "Assets" );
|
|
string uniquePath = ( indexOfAssets > 0 ) ? pathName.Remove( 0 , indexOfAssets ) : pathName;
|
|
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath( uniquePath + shaderName + ".shader" );
|
|
pathName = assetPathAndName;
|
|
shaderName = assetPathAndName.Remove( 0 , assetPathAndName.IndexOf( shaderName ) );
|
|
}
|
|
else
|
|
{
|
|
shaderName = customShaderName;
|
|
}
|
|
shaderName = shaderName.Remove( shaderName.Length - 7 );
|
|
}
|
|
if( !System.String.IsNullOrEmpty( shaderName ) && !System.String.IsNullOrEmpty( pathName ) )
|
|
{
|
|
m_latestOpenedFolder = pathName;
|
|
|
|
CurrentWindow.titleContent.text = AmplifyShaderEditorWindow.GenerateTabTitle( shaderName );
|
|
CurrentWindow.titleContent.image = ShaderIcon;
|
|
CurrentWindow.CreateNewGraph( shaderName );
|
|
CurrentWindow.LastOpenedLocation = pathName;
|
|
CurrentWindow.CurrentGraph.CurrentMasterNode.SetName( shaderName );
|
|
newShader = CurrentWindow.CurrentGraph.FireMasterNode( pathName , true );
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
return newShader;
|
|
}
|
|
|
|
|
|
public static Shader CreateNewEmptyTemplate( string templateGUID , string customPath = null , string customShaderName = null )
|
|
{
|
|
if( CurrentWindow == null )
|
|
return null;
|
|
|
|
string shaderName;
|
|
string pathName;
|
|
Shader newShader = null;
|
|
|
|
|
|
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 ) ) , "" );
|
|
}
|
|
|
|
|
|
if( string.IsNullOrEmpty( customPath ) )
|
|
{
|
|
IOUtils.GetShaderName( out shaderName , out pathName , Constants.DefaultShaderName , m_latestOpenedFolder );
|
|
}
|
|
else
|
|
{
|
|
pathName = customPath;
|
|
if( string.IsNullOrEmpty( customShaderName ) )
|
|
{
|
|
shaderName = Constants.DefaultShaderName;
|
|
int indexOfAssets = pathName.IndexOf( "Assets" );
|
|
string uniquePath = ( indexOfAssets > 0 ) ? pathName.Remove( 0 , indexOfAssets ) : pathName;
|
|
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath( uniquePath + shaderName + ".shader" );
|
|
pathName = assetPathAndName;
|
|
shaderName = assetPathAndName.Remove( 0 , assetPathAndName.IndexOf( shaderName ) );
|
|
}
|
|
else
|
|
{
|
|
shaderName = customShaderName;
|
|
}
|
|
shaderName = shaderName.Remove( shaderName.Length - 7 );
|
|
}
|
|
if( !System.String.IsNullOrEmpty( shaderName ) && !System.String.IsNullOrEmpty( pathName ) )
|
|
{
|
|
m_latestOpenedFolder = pathName;
|
|
|
|
CurrentWindow.titleContent.text = AmplifyShaderEditorWindow.GenerateTabTitle( shaderName );
|
|
CurrentWindow.titleContent.image = UIUtils.ShaderIcon;
|
|
CurrentWindow.CreateNewTemplateGraph( templateGUID );
|
|
CurrentWindow.CurrentGraph.CurrentMasterNode.SetName( shaderName );
|
|
newShader = CurrentWindow.CurrentGraph.FireMasterNode( pathName , true );
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
return newShader;
|
|
}
|
|
|
|
|
|
public static void SetDelayedMaterialMode( Material material )
|
|
{
|
|
if( CurrentWindow == null )
|
|
return;
|
|
CurrentWindow.SetDelayedMaterialMode( material );
|
|
}
|
|
|
|
public static void CreateEmptyFromInvalid( Shader shader )
|
|
{
|
|
if( CurrentWindow == null )
|
|
return;
|
|
|
|
CurrentWindow.CreateNewGraph( shader );
|
|
CurrentWindow.ForceRepaint();
|
|
}
|
|
|
|
public static void CreateEmptyFunction( AmplifyShaderFunction shaderFunction )
|
|
{
|
|
if( CurrentWindow == null )
|
|
return;
|
|
|
|
CurrentWindow.CreateNewFunctionGraph( shaderFunction );
|
|
CurrentWindow.SaveToDisk( false );
|
|
CurrentWindow.ForceRepaint();
|
|
}
|
|
|
|
public static void DrawFloat( UndoParentNode owner , ref Rect propertyDrawPos , ref float value , float newLabelWidth = 8 )
|
|
{
|
|
float labelWidth = EditorGUIUtility.labelWidth;
|
|
EditorGUIUtility.labelWidth = newLabelWidth;
|
|
value = owner.EditorGUIFloatField( propertyDrawPos , " " , value , UIUtils.MainSkin.textField );
|
|
EditorGUIUtility.labelWidth = labelWidth;
|
|
}
|
|
|
|
public static GUIStyle GetCustomStyle( CustomStyle style )
|
|
{
|
|
return ( Initialized ) ? MainSkin.customStyles[ (int)style ] : null;
|
|
}
|
|
|
|
public static void SetCustomStyle( CustomStyle style , GUIStyle guiStyle )
|
|
{
|
|
if( MainSkin != null )
|
|
MainSkin.customStyles[ (int)style ] = new GUIStyle( guiStyle );
|
|
}
|
|
|
|
public static void OpenFile()
|
|
{
|
|
if( CurrentWindow == null )
|
|
return;
|
|
string newShader = EditorUtility.OpenFilePanel( "Select Shader to open" , m_latestOpenedFolder , "shader" );
|
|
if( !System.String.IsNullOrEmpty( newShader ) )
|
|
{
|
|
m_latestOpenedFolder = newShader.Substring( 0 , newShader.LastIndexOf( '/' ) + 1 );
|
|
int relFilenameId = newShader.IndexOf( Application.dataPath );
|
|
if( relFilenameId > -1 )
|
|
{
|
|
string relFilename = newShader.Substring( relFilenameId + Application.dataPath.Length - 6 );// -6 need to also copy the assets/ part
|
|
CurrentWindow.LoadFromDisk( relFilename );
|
|
}
|
|
else
|
|
{
|
|
ShowMessage( "Can only load shaders\nfrom inside the projects folder" , MessageSeverity.Error );
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool DetectNodeLoopsFrom( ParentNode node , Dictionary<int , int> currentNodes )
|
|
{
|
|
for( int i = 0 ; i < node.InputPorts.Count ; i++ )
|
|
{
|
|
if( node.InputPorts[ i ].IsConnected )
|
|
{
|
|
ParentNode newNode = node.InputPorts[ i ].GetOutputNode();
|
|
if( !currentNodes.ContainsKey( newNode.UniqueId ) )
|
|
RecursiveNodeFill( newNode , currentNodes );
|
|
}
|
|
}
|
|
|
|
bool found = currentNodes.ContainsKey( node.UniqueId );
|
|
currentNodes.Clear();
|
|
currentNodes = null;
|
|
|
|
return found;
|
|
}
|
|
|
|
private static void RecursiveNodeFill( ParentNode node , Dictionary<int , int> currentNodes )
|
|
{
|
|
if( !currentNodes.ContainsKey( node.UniqueId ) )
|
|
currentNodes.Add( node.UniqueId , 1 );
|
|
|
|
for( int i = 0 ; i < node.InputPorts.Count ; i++ )
|
|
{
|
|
if( node.InputPorts[ i ].IsConnected )
|
|
{
|
|
ParentNode newNode = node.InputPorts[ i ].GetOutputNode();
|
|
if( !currentNodes.ContainsKey( newNode.UniqueId ) )
|
|
RecursiveNodeFill( newNode , currentNodes );
|
|
}
|
|
}
|
|
}
|
|
|
|
public static ParentNode CreateNode( System.Type type , bool registerUndo , Vector2 pos , int nodeId = -1 , bool addLast = true )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.CreateNode( type , registerUndo , pos , nodeId , addLast );
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static void DestroyNode( int nodeId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.CurrentGraph.DestroyNode( nodeId );
|
|
}
|
|
}
|
|
|
|
public static void ShowMessage( int ownerId , string message , MessageSeverity severity = MessageSeverity.Normal , bool registerTimestamp = true )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.ShowMessage( ownerId , message , severity , registerTimestamp );
|
|
}
|
|
}
|
|
|
|
public static void ShowMessage( string message , MessageSeverity severity = MessageSeverity.Normal , bool registerTimestamp = true )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.ShowMessage( message , severity , registerTimestamp );
|
|
}
|
|
}
|
|
|
|
public static ParentNode GetNode( int nodeId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.GetNode( nodeId );
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static PropertyNode GetInternalTemplateNode( int nodeId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.GetInternalTemplateNode( nodeId );
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static PropertyNode GetInternalTemplateNode( string propertyName )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.GetInternalTemplateNode( propertyName );
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
public static void DeleteConnection( bool isInput , int nodeId , int portId , bool registerOnLog , bool propagateCallback )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.DeleteConnection( isInput , nodeId , portId , registerOnLog , propagateCallback );
|
|
}
|
|
}
|
|
|
|
public static void ConnectInputToOutput( int inNodeId , int inPortId , int outNodeId , int outPortId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.ConnectInputToOutput( inNodeId , inPortId , outNodeId , outPortId );
|
|
}
|
|
}
|
|
|
|
public static Shader CreateNewGraph( string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CreateNewGraph( name );
|
|
}
|
|
return null;
|
|
}
|
|
public static void SetConnection( int InNodeId , int InPortId , int OutNodeId , int OutPortId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.CurrentGraph.SetConnection( InNodeId , InPortId , OutNodeId , OutPortId );
|
|
}
|
|
}
|
|
|
|
public static bool IsChannelAvailable( int channelId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.IsChannelAvailable( channelId );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool ReleaseUVChannel( int nodeId , int channelId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.ReleaseUVChannel( nodeId , channelId );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool RegisterUVChannel( int nodeId , int channelId , string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.RegisterUVChannel( nodeId , channelId , name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static void GetFirstAvailableName( int nodeId , WirePortDataType type , out string outProperty , out string outInspector , bool useCustomPrefix = false , string customPrefix = null )
|
|
{
|
|
outProperty = string.Empty;
|
|
outInspector = string.Empty;
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.DuplicatePrevBufferInstance.GetFirstAvailableName( nodeId , type , out outProperty , out outInspector , useCustomPrefix , customPrefix );
|
|
}
|
|
}
|
|
|
|
|
|
public static bool IsNumericName( string name )
|
|
{
|
|
Match match = Regex.Match( name , NumericNamePattern );
|
|
if( match != null && match.Success )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public static bool CheckInvalidUniformName( string name )
|
|
{
|
|
if( m_reservedPropertyNames.ContainsKey( name ) )
|
|
{
|
|
ShowMessage( string.Format( Constants.ReservedPropertyNameStr , name ) );
|
|
return true;
|
|
}
|
|
|
|
if( IsNumericName( name ) )
|
|
{
|
|
ShowMessage( string.Format( Constants.NumericPropertyNameStr , name ) );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool RegisterUniformName( int nodeId , string name )
|
|
{
|
|
if( CheckInvalidUniformName( name ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.RegisterUniformName( nodeId , name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool ReleaseUniformName( int nodeId , string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.ReleaseUniformName( nodeId , name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsUniformNameAvailable( string name )
|
|
{
|
|
if( CheckInvalidUniformName( name ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.IsUniformNameAvailable( name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static int CheckUniformNameOwner( string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.CheckUniformNameOwner( name );
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static string GetUniqueUniformName( string name )
|
|
{
|
|
int num = 0;
|
|
Regex reg = new Regex( @"([0-9]+)$" );
|
|
Match match = reg.Match( name );
|
|
if( match.Success )
|
|
{
|
|
string s = match.Groups[ 1 ].Captures[ 0 ].Value;
|
|
num = int.Parse( s );
|
|
name = name.Replace( s , "" );
|
|
}
|
|
|
|
for( int i = num + 1 ; i < 1000 ; i++ )
|
|
{
|
|
string testName = name + i;
|
|
|
|
if( CheckInvalidUniformName( testName ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( CurrentWindow != null )
|
|
{
|
|
if( CurrentWindow.DuplicatePrevBufferInstance.IsUniformNameAvailable( testName ) )
|
|
{
|
|
return testName;
|
|
}
|
|
}
|
|
}
|
|
return name;
|
|
}
|
|
|
|
public static bool RegisterLocalVariableName( int nodeId , string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.RegisterLocalVariableName( nodeId , name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool ReleaseLocalVariableName( int nodeId , string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.ReleaseLocalVariableName( nodeId , name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsLocalvariableNameAvailable( string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.IsLocalvariableNameAvailable( name );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static string GetChannelName( int channelId )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.GetChannelName( channelId );
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
public static void SetChannelName( int channelId , string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
CurrentWindow.DuplicatePrevBufferInstance.SetChannelName( channelId , name );
|
|
}
|
|
}
|
|
|
|
public static int RegisterFirstAvailableChannel( int nodeId , string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.DuplicatePrevBufferInstance.RegisterFirstAvailableChannel( nodeId , name );
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int PortCategorytoAttayIdx( MasterNodePortCategory category )
|
|
{
|
|
if( m_portCategoryToArrayIdx.ContainsKey( category ) )
|
|
return m_portCategoryToArrayIdx[ category ];
|
|
|
|
return m_portCategoryToArrayIdx[ MasterNodePortCategory.Fragment ];
|
|
}
|
|
|
|
public static bool DisplayDialog( string shaderPath )
|
|
{
|
|
string value = System.String.Format( "Save changes to the shader {0} before closing?" , shaderPath );
|
|
return EditorUtility.DisplayDialog( "Load selected" , value , "Yes" , "No" );
|
|
}
|
|
|
|
public static void ForceUpdateFromMaterial()
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
// CurrentWindow.Focus();
|
|
CurrentWindow.ForceUpdateFromMaterial();
|
|
}
|
|
}
|
|
|
|
public static void MarkToRepaint() { if( CurrentWindow != null ) CurrentWindow.MarkToRepaint(); }
|
|
public static void RequestSave() { if( CurrentWindow != null ) CurrentWindow.RequestSave(); }
|
|
public static string FloatToString( float value )
|
|
{
|
|
string floatStr = value.ToString();
|
|
if( value % 1 == 0 )
|
|
{
|
|
floatStr += ".0";
|
|
}
|
|
return floatStr;
|
|
}
|
|
|
|
public static int CurrentShaderVersion()
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.LoadedShaderVersion;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static bool IsProperty( PropertyType type ) { return ( type == PropertyType.Property || type == PropertyType.InstancedProperty ); }
|
|
|
|
public static MasterNode CurrentMasterNode()
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.CurrentMasterNode;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static void AddVirtualTextureCount() { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.AddVirtualTextureCount(); } }
|
|
|
|
public static bool HasVirtualTexture()
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.HasVirtualTexture;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static void RemoveVirtualTextureCount() { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.RemoveVirtualTextureCount(); } }
|
|
|
|
//public static void AddInstancePropertyCount() { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.AddInstancePropertyCount(); } }
|
|
|
|
public static bool IsInstancedShader()
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
return CurrentWindow.CurrentGraph.IsInstancedShader;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//public static void RemoveInstancePropertyCount() { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.RemoveInstancePropertyCount(); } }
|
|
//public static void AddNormalDependentCount() { if ( CurrentWindow != null ) { CurrentWindow.CurrentGraph.AddNormalDependentCount(); } }
|
|
//public static void RemoveNormalDependentCount() { if ( CurrentWindow != null ) { CurrentWindow.CurrentGraph.RemoveNormalDependentCount(); } }
|
|
//public static bool IsNormalDependent()
|
|
//{
|
|
// if ( CurrentWindow != null )
|
|
// {
|
|
// return CurrentWindow.CurrentGraph.IsNormalDependent;
|
|
// }
|
|
// return false;
|
|
//}
|
|
|
|
public static void CopyValuesFromMaterial( Material mat )
|
|
{
|
|
if( CurrentWindow != null && CurrentWindow.CurrentMaterial == mat )
|
|
{
|
|
CurrentWindow.CurrentGraph.CopyValuesFromMaterial( mat );
|
|
}
|
|
else
|
|
{
|
|
int aseWindowCount = IOUtils.AllOpenedWindows.Count;
|
|
for( int i = 0 ; i < aseWindowCount ; i++ )
|
|
{
|
|
if( IOUtils.AllOpenedWindows[ i ] != m_currentWindow && IOUtils.AllOpenedWindows[ i ].CurrentMaterial == mat )
|
|
{
|
|
IOUtils.AllOpenedWindows[ i ].CurrentGraph.CopyValuesFromMaterial( mat );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sampler Node
|
|
public static void RegisterSamplerNode( SamplerNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.SamplerNodes.AddNode( node ); } }
|
|
public static void UnregisterSamplerNode( SamplerNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.SamplerNodes.RemoveNode( node ); } }
|
|
public static string[] SamplerNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.SamplerNodes.NodesArr; } return null; }
|
|
public static SamplerNode GetSamplerNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.SamplerNodes.GetNode( idx ); } return null; }
|
|
public static void UpdateSamplerDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.SamplerNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetSamplerNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.SamplerNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static int GetSamplerNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.SamplerNodes.NodesList.Count; } return -1; }
|
|
|
|
// Float Node
|
|
public static void RegisterFloatIntNode( PropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FloatIntNodes.AddNode( node ); } }
|
|
public static void UnregisterFloatIntNode( PropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FloatIntNodes.RemoveNode( node ); } }
|
|
public static string[] FloatIntNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FloatIntNodes.NodesArr; } return null; }
|
|
public static int[] FloatIntNodeIds() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FloatIntNodes.NodeIds; } return null; }
|
|
public static PropertyNode GetFloatIntNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FloatIntNodes.GetNode( idx ); } return null; }
|
|
public static void UpdateFloatIntDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FloatIntNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetFloatIntNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FloatIntNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static int GetNodeIdByName( string name )
|
|
{
|
|
if( CurrentWindow != null )
|
|
{
|
|
UsageListFloatIntNodes list = CurrentWindow.CurrentGraph.FloatIntNodes;
|
|
int count = list.Count;
|
|
for( int i = 0 ; i < count ; i++ )
|
|
{
|
|
if( list.NodesList[ i ].PropertyName.Equals( name ) )
|
|
return list.NodesList[ i ].UniqueId;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
public static PropertyNode GetFloatIntNodeByUniqueId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FloatIntNodes.GetNodeByUniqueId( uniqueId ); } return null; }
|
|
//public static int GetFloatNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FloatNodes.NodesList.Count; } return -1; }
|
|
|
|
// Texture Property
|
|
public static void RegisterTexturePropertyNode( TexturePropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.TexturePropertyNodes.AddNode( node ); } }
|
|
public static void UnregisterTexturePropertyNode( TexturePropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.TexturePropertyNodes.RemoveNode( node ); } }
|
|
public static string[] TexturePropertyNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TexturePropertyNodes.NodesArr; } return null; }
|
|
public static TexturePropertyNode GetTexturePropertyNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TexturePropertyNodes.GetNode( idx ); } return null; }
|
|
public static void UpdateTexturePropertyDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.TexturePropertyNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetTexturePropertyNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TexturePropertyNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static int GetTexturePropertyNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TexturePropertyNodes.NodesList.Count; } return -1; }
|
|
|
|
// Texture Array
|
|
public static void RegisterTextureArrayNode( TextureArrayNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.TextureArrayNodes.AddNode( node ); } }
|
|
public static void UnregisterTextureArrayNode( TextureArrayNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.TextureArrayNodes.RemoveNode( node ); } }
|
|
public static string[] TextureArrayNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TextureArrayNodes.NodesArr; } return null; }
|
|
public static TextureArrayNode GetTextureArrayNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TextureArrayNodes.GetNode( idx ); } return null; }
|
|
public static void UpdateTextureArrayDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.TextureArrayNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetTextureArrayNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TextureArrayNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static int GetTextureArrayNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.TextureArrayNodes.NodesList.Count; } return -1; }
|
|
|
|
// Raw Property Node
|
|
public static void RegisterRawPropertyNode( PropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.OutsideGraph.RawPropertyNodes.AddNode( node ); } }
|
|
public static void UnregisterRawPropertyNode( PropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.OutsideGraph.RawPropertyNodes.RemoveNode( node ); } }
|
|
|
|
// Property Node
|
|
public static void RegisterPropertyNode( PropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.PropertyNodes.AddNode( node ); } }
|
|
public static void UnregisterPropertyNode( PropertyNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.PropertyNodes.RemoveNode( node ); } }
|
|
public static string[] PropertyNodeNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.PropertyNodes.NodesArr; } return null; }
|
|
public static PropertyNode GetPropertyNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.PropertyNodes.GetNode( idx ); } return null; }
|
|
public static PropertyNode GetPropertyNodeByUniqueId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.PropertyNodes.GetNodeByUniqueId( uniqueId ); } return null; }
|
|
public static void UpdatePropertyDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.PropertyNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetPropertyNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.PropertyNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static List<PropertyNode> PropertyNodesList() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.PropertyNodes.NodesList; } return null; }
|
|
public static int GetPropertyNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.PropertyNodes.NodesList.Count; } return -1; }
|
|
|
|
// Function Inputs
|
|
public static void RegisterFunctionInputNode( FunctionInput node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionInputNodes.AddNode( node ); } }
|
|
public static void UnregisterFunctionInputNode( FunctionInput node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionInputNodes.RemoveNode( node ); } }
|
|
public static void UpdateFunctionInputData( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionInputNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static List<FunctionInput> FunctionInputList() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionInputNodes.NodesList; } return null; }
|
|
|
|
// Function Nodes
|
|
public static void RegisterFunctionNode( FunctionNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionNodes.AddNode( node ); } }
|
|
public static void UnregisterFunctionNode( FunctionNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionNodes.RemoveNode( node ); } }
|
|
public static void UpdateFunctionData( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static List<FunctionNode> FunctionList() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionNodes.NodesList; } return null; }
|
|
|
|
// Function Outputs
|
|
public static void RegisterFunctionOutputNode( FunctionOutput node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionOutputNodes.AddNode( node ); } }
|
|
public static void UnregisterFunctionOutputNode( FunctionOutput node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionOutputNodes.RemoveNode( node ); } }
|
|
public static void UpdateFunctionOutputData( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionOutputNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static List<FunctionOutput> FunctionOutputList() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionOutputNodes.NodesList; } return null; }
|
|
|
|
// Function Switches Copy
|
|
public static void RegisterFunctionSwitchCopyNode( FunctionSwitch node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchCopyNodes.AddNode( node ); } }
|
|
public static void UnregisterFunctionSwitchCopyNode( FunctionSwitch node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchCopyNodes.RemoveNode( node ); } }
|
|
public static void UpdateFunctionSwitchCopyData( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchCopyNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static List<FunctionSwitch> FunctionSwitchCopyList() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionSwitchCopyNodes.NodesList; } return null; }
|
|
|
|
// Function Switches
|
|
public static void RegisterFunctionSwitchNode( FunctionSwitch node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchNodes.AddNode( node ); } }
|
|
public static void UnregisterFunctionSwitchNode( FunctionSwitch node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchNodes.RemoveNode( node ); } }
|
|
public static void UpdateFunctionSwitchData( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static List<FunctionSwitch> FunctionSwitchList() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionSwitchNodes.NodesList; } return null; }
|
|
public static void UpdateFunctionSwitchArr() { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.FunctionSwitchNodes.UpdateNodeArr(); } }
|
|
public static string[] FunctionSwitchesNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionSwitchNodes.NodesArr; } return null; }
|
|
public static FunctionSwitch GetFunctionSwitchNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionSwitchNodes.GetNode( idx ); } return null; }
|
|
public static int GetFunctionSwitchNodeIndex( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.FunctionSwitchNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
|
|
// Screen Color Node
|
|
public static void RegisterScreenColorNode( ScreenColorNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.ScreenColorNodes.AddNode( node ); } }
|
|
public static void UnregisterScreenColorNode( ScreenColorNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.ScreenColorNodes.RemoveNode( node ); } }
|
|
public static string[] ScreenColorNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.ScreenColorNodes.NodesArr; } return null; }
|
|
public static ScreenColorNode GetScreenColorNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.ScreenColorNodes.GetNode( idx ); } return null; }
|
|
public static int GetScreenColorNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.ScreenColorNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static void UpdateScreenColorDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.ScreenColorNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetScreenColorNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.ScreenColorNodes.NodesList.Count; } return -1; }
|
|
|
|
// Local Var Node
|
|
public static int RegisterLocalVarNode( RegisterLocalVarNode node ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.LocalVarNodes.AddNode( node ); } return -1; }
|
|
public static void UnregisterLocalVarNode( RegisterLocalVarNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.LocalVarNodes.RemoveNode( node ); } }
|
|
public static string[] LocalVarNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.LocalVarNodes.NodesArr; } return null; }
|
|
public static int LocalVarNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.LocalVarNodes.NodesList.Count; } return 0; }
|
|
public static int GetLocalVarNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.LocalVarNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static RegisterLocalVarNode GetLocalVarNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.LocalVarNodes.GetNode( idx ); } return null; }
|
|
public static void UpdateLocalVarDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.LocalVarNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
|
|
//Global Array
|
|
public static void RegisterGlobalArrayNode( GlobalArrayNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.GlobalArrayNodes.AddNode( node ); } }
|
|
public static void UnregisterGlobalArrayNode( GlobalArrayNode node ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.GlobalArrayNodes.RemoveNode( node ); } }
|
|
public static string[] GlobalArrayNodeArr() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.GlobalArrayNodes.NodesArr; } return null; }
|
|
public static GlobalArrayNode GetGlobalArrayNode( int idx ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.GlobalArrayNodes.GetNode( idx ); } return null; }
|
|
public static int GetGlobalArrayNodeRegisterId( int uniqueId ) { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.GlobalArrayNodes.GetNodeRegisterIdx( uniqueId ); } return -1; }
|
|
public static void UpdateGlobalArrayDataNode( int uniqueId , string data ) { if( CurrentWindow != null ) { CurrentWindow.CurrentGraph.GlobalArrayNodes.UpdateDataOnNode( uniqueId , data ); } }
|
|
public static int GetGlobalArrayNodeAmount() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.GlobalArrayNodes.NodesList.Count; } return -1; }
|
|
|
|
|
|
public static void FocusOnNode( ParentNode node , float zoom , bool selectNode ) { if( CurrentWindow != null ) { CurrentWindow.FocusOnNode( node , zoom , selectNode ); } }
|
|
public static PrecisionType CurrentPrecision() { if( CurrentWindow != null ) { return CurrentWindow.CurrentGraph.CurrentPrecision; } return PrecisionType.Float; }
|
|
public static string CurrentPrecisionCg() { if( CurrentWindow != null ) { return m_precisionTypeToCg[ CurrentWindow.CurrentGraph.CurrentPrecision ]; } return m_precisionTypeToCg[ PrecisionType.Float ]; }
|
|
|
|
public static PrecisionType GetFinalPrecision( PrecisionType precision )
|
|
{
|
|
if( CurrentWindow != null && CurrentWindow.CurrentGraph != null )
|
|
{
|
|
PrecisionType mainPrecision = CurrentWindow.CurrentGraph.CurrentPrecision;
|
|
if( (int)mainPrecision > (int)precision )
|
|
return mainPrecision;
|
|
}
|
|
return precision;
|
|
}
|
|
|
|
public static bool GetNodeAvailabilityInBitArray( int bitArray , NodeAvailability availability ) { return ( bitArray & (int)availability ) != 0; }
|
|
public static bool GetCategoryInBitArray( int bitArray , MasterNodePortCategory category ) { return ( bitArray & (int)category ) != 0; }
|
|
public static void SetCategoryInBitArray( ref int bitArray , MasterNodePortCategory category ) { bitArray = bitArray | (int)category; }
|
|
|
|
public static int GetPriority( WirePortDataType type ) { return m_portPriority[ type ]; }
|
|
|
|
public static void ShowIncompatiblePortMessage( bool fromInput , ParentNode inNode , WirePort inPort , ParentNode outNode , WirePort outPort )
|
|
{
|
|
string inPortName = inPort.Name.Equals( Constants.EmptyPortValue ) ? inPort.PortId.ToString() : inPort.Name;
|
|
string outPortName = outPort.Name.Equals( Constants.EmptyPortValue ) ? outPort.PortId.ToString() : outPort.Name;
|
|
ShowMessage( outNode.UniqueId , string.Format( ( fromInput ? IncorrectInputConnectionErrorMsg : IncorrectOutputConnectionErrorMsg ) , inPortName , inNode.Attributes.Name , inPort.DataType , outPort.DataType , outPortName , outNode.Attributes.Name ) );
|
|
}
|
|
|
|
public static void ShowNoVertexModeNodeMessage( ParentNode node )
|
|
{
|
|
ShowMessage( node.UniqueId , string.Format( NoVertexModeNodeWarning , node.Attributes.Name ) , MessageSeverity.Warning );
|
|
}
|
|
|
|
public static int TotalExampleMaterials { get { return m_exampleMaterialIDs.Count; } }
|
|
|
|
public static int ShaderIndentLevel
|
|
{
|
|
get { return m_shaderIndentLevel; }
|
|
set
|
|
{
|
|
m_shaderIndentLevel = Mathf.Max( value , 0 );
|
|
m_shaderIndentTabs = string.Empty;
|
|
for( int i = 0 ; i < m_shaderIndentLevel ; i++ ) { m_shaderIndentTabs += "\t"; }
|
|
}
|
|
}
|
|
|
|
public static string ShaderIndentTabs { get { return m_shaderIndentTabs; } }
|
|
public static void AddLineToShaderBody( ref string ShaderBody , string line ) { ShaderBody += m_shaderIndentTabs + line; }
|
|
public static void AddMultiLineToShaderBody( ref string ShaderBody , string[] lines )
|
|
{
|
|
for( int i = 0 ; i < lines.Length ; i++ )
|
|
{
|
|
ShaderBody += m_shaderIndentTabs + lines[ i ];
|
|
}
|
|
}
|
|
|
|
public static void ClearUndoHelper()
|
|
{
|
|
m_undoHelper.Clear();
|
|
}
|
|
|
|
public static bool CheckUndoNode( ParentNode node )
|
|
{
|
|
if( node == null )
|
|
return false;
|
|
if( m_undoHelper.ContainsKey( node.UniqueId ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_undoHelper.Add( node.UniqueId , node );
|
|
EditorUtility.SetDirty( node );
|
|
return true;
|
|
}
|
|
|
|
public static void MarkUndoAction()
|
|
{
|
|
SerializeHelperCounter = 2;
|
|
}
|
|
|
|
public static bool SerializeFromUndo()
|
|
{
|
|
if( SerializeHelperCounter > 0 )
|
|
{
|
|
SerializeHelperCounter--;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static int GetKeywordId( string keyword , TemplateSRPType type = TemplateSRPType.BuiltIn )
|
|
{
|
|
switch( type )
|
|
{
|
|
default:
|
|
case TemplateSRPType.BuiltIn:
|
|
{
|
|
if( AvailableKeywordsDict.Count != AvailableKeywords.Length )
|
|
{
|
|
AvailableKeywordsDict.Clear();
|
|
for( int i = 1 ; i < AvailableKeywords.Length ; i++ )
|
|
{
|
|
AvailableKeywordsDict.Add( AvailableKeywords[ i ] , i );
|
|
}
|
|
}
|
|
|
|
if( AvailableKeywordsDict.ContainsKey( keyword ) )
|
|
{
|
|
return AvailableKeywordsDict[ keyword ];
|
|
}
|
|
}
|
|
break;
|
|
case TemplateSRPType.HD:
|
|
case TemplateSRPType.Lightweight:
|
|
{
|
|
if( AvailableURPKeywordsDict.Count != AvailableURPKeywords.Length )
|
|
{
|
|
AvailableURPKeywordsDict.Clear();
|
|
for( int i = 1 ; i < AvailableURPKeywords.Length ; i++ )
|
|
{
|
|
AvailableURPKeywordsDict.Add( AvailableURPKeywords[ i ] , i );
|
|
}
|
|
}
|
|
|
|
if( AvailableURPKeywordsDict.ContainsKey( keyword ) )
|
|
{
|
|
return AvailableURPKeywordsDict[ keyword ];
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
public static string ForceLFLineEnding( string body )
|
|
{
|
|
body = body.Replace( "\r\n" , "\n" );
|
|
body = body.Replace( "\r" , "\n" );
|
|
return body;
|
|
}
|
|
|
|
public static RenderTexture DummyRT
|
|
{
|
|
get
|
|
{
|
|
if( m_dummyPreviewRT == null )
|
|
{
|
|
m_dummyPreviewRT = new RenderTexture( 128 , 128 , 0 , RenderTextureFormat.ARGB32 );
|
|
RenderTexture temp = RenderTexture.active;
|
|
RenderTexture.active = m_dummyPreviewRT;
|
|
Graphics.Blit( Texture2D.blackTexture , m_dummyPreviewRT );
|
|
RenderTexture.active = temp;
|
|
}
|
|
return m_dummyPreviewRT;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|