public bool CheckCanCompile()
{
editor.nodeView.RefreshRelaySources();
if (Errors == null)
{
Errors = new List <SF_ErrorEntry>();
}
else if (Errors.Count > 0)
{
for (int i = 0; i < Errors.Count; i++)
{
DestroyImmediate(Errors[i]);
}
Errors.Clear();
}
List <SF_Node> cNodes = GetListOfConnectedNodesWithGhosts(out editor.shaderEvaluator.ghostNodes);
// If any properties are now outside the node graph, remove them from the property list
/*if(!SF_Parser.settingUp)
* for( int i = propertyList.Count - 1; i >= 0; i-- ) {
* if( !cNodes.Contains( propertyList[i] ) ) {
* propertyList.RemoveAt( i );
* }
* }*/
//if( editor.shaderEvaluator.ghostNodes != null )
//Debug.Log( "Ghost nodes: " + editor.shaderEvaluator.ghostNodes.Count );
texturesInVertShader = false;
bool foundMipUsed = false;
//SF_Node mipNode = null;
usesSceneData = false;
bool hasFacingNode = false;
foreach (SF_Node n in cNodes)
{
// Refresh property list
if (n.IsProperty())
{
if (!n.IsGlobalProperty())
{
// Add if it's local and doesn't contain it already
if (!propertyList.Contains(n))
{
propertyList.Add(n);
}
}
else
{
// Remove it if it's global and inside the list
if (propertyList.Contains(n))
{
propertyList.Remove(n);
}
}
}
if (n is SFN_SceneColor)
{
usesSceneData = true;
}
if (n is SFN_FaceSign)
{
hasFacingNode = true;
}
if (n is SFN_Tex2d || n is SFN_Cubemap) // Check MIP input
{
if (n.GetInputIsConnected("MIP"))
{
foundMipUsed = true;
//mipNode = n;
}
}
//if(SF_Debug.dynamicNodeLoad)
if (SF_Editor.NodeExistsAndIs(n, "SFN_SkyshopSpec"))
{
//if(n.GetInputIsConnected("GLOSS")){
foundMipUsed = true;
//mipNode = n;
//}
}
foreach (SF_NodeConnector con in n.connectors)
{
if (con.conType == ConType.cOutput)
{
continue;
}
if (con.required && !con.IsConnected())
{
string err = "Missing required";
err += string.IsNullOrEmpty(con.label) ? " " : " [" + con.label + "] ";
err += "input on " + con.node.nodeName;
Errors.Add(SF_ErrorEntry.Create(err, con, false));
}
}
}
// WARNINGS
if (editor.ps.catBlending.autoSort)
{
bool alphaConnected = editor.ps.HasAlpha();
if (editor.ps.catLighting.transparencyMode == SFPSC_Lighting.TransparencyMode.Fade)
{
bool usingAlphaBlend = editor.ps.catBlending.blendSrc == BlendMode.SrcAlpha && editor.ps.catBlending.blendDst == BlendMode.OneMinusSrcAlpha;
if (alphaConnected && !usingAlphaBlend)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Opacity is connected, but your shader isn't alpha blended, which is required by the fade transparency mode. Click the icon to make it alpha blended!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catBlending, "error correction");
editor.ps.catBlending.blendModePreset = BlendModePreset.AlphaBlended;
editor.ps.catBlending.ConformBlendsToPreset();
};
Errors.Add(error);
}
if (!alphaConnected && usingAlphaBlend)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Opacity is not connected, but your shader is alpha blended. Click the icon to make it opaque!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catBlending, "error correction");
editor.ps.catBlending.blendModePreset = BlendModePreset.Opaque;
editor.ps.catBlending.ConformBlendsToPreset();
};
Errors.Add(error);
}
}
if (editor.ps.catLighting.transparencyMode == SFPSC_Lighting.TransparencyMode.Reflective)
{
bool usingAlphaBlendPremul = editor.ps.catBlending.blendSrc == BlendMode.One && editor.ps.catBlending.blendDst == BlendMode.OneMinusSrcAlpha;
if (alphaConnected && !usingAlphaBlendPremul)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Opacity is connected, but your shader isn't using premultiplied alpha blending, which is required by the reflective transparency mode. Click the icon to use premultiplied alpha blending!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catBlending, "error correction");
editor.ps.catBlending.blendModePreset = BlendModePreset.AlphaBlendedPremultiplied;
editor.ps.catBlending.ConformBlendsToPreset();
};
Errors.Add(error);
}
if (!alphaConnected && usingAlphaBlendPremul)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Opacity is not connected, but your shader is using premultiplied alpha blending. Click the icon to make it opaque!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catBlending, "error correction");
editor.ps.catBlending.blendModePreset = BlendModePreset.Opaque;
editor.ps.catBlending.ConformBlendsToPreset();
};
Errors.Add(error);
}
}
}
/*
* true, // - Direct3D 9
* true, // - Direct3D 11
* true, // - OpenGL
* true, // - OpenGL ES 2.0
* false, // - Xbox 360
* false, // - PlayStation 3
* false, // - Flash
* false // - Direct3D 11 for Windows RT
*/
bool osx = Application.platform == RuntimePlatform.OSXEditor;
bool windows = !osx;
bool ogl = editor.ps.catMeta.usedRenderers[2];
bool dx9 = editor.ps.catMeta.usedRenderers[0];
bool dx11 = editor.ps.catMeta.usedRenderers[1];
#if UNITY_5_0
bool inDx11Mode = UnityEditor.PlayerSettings.useDirect3D11;
#else
bool inDx11Mode = true;
#endif
if (osx && !ogl)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Your shader will not render properly on your workstation - you need to have OpenGL enabled when working in OSX. Click the icon to enable OpenGL!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catMeta, "error correction - enable OpenGL");
editor.ps.catMeta.usedRenderers[2] = true;
editor.OnShaderModified(NodeUpdateType.Hard);
};
Errors.Add(error);
}
else if (windows)
{
if (inDx11Mode && !dx11)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Your shader might not render properly on your workstation - you need to have Direct3D 11 enabled when working in DX11 mode on Windows. Click the icon to enable Direct3D 11!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catMeta, "error correction - enable Direct3D 11");
editor.ps.catMeta.usedRenderers[1] = true;
editor.OnShaderModified(NodeUpdateType.Soft);
};
Errors.Add(error);
}
else if (!inDx11Mode && !dx9)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("Your shader might not render properly on your workstation - you need to have Direct3D 9 enabled when working on Windows. Click the icon to enable Direct3D 9!", true);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catMeta, "error correction - enable Direct3D 9");
editor.ps.catMeta.usedRenderers[0] = true;
editor.OnShaderModified(NodeUpdateType.Soft);
};
Errors.Add(error);
}
}
if (editor.ps.catLighting.lightMode == SFPSC_Lighting.LightMode.PBL)
{
if (editor.ps.HasDiffuse() && !editor.ps.HasSpecular())
{
Errors.Add(SF_ErrorEntry.Create("Using PBL requires metallic/specular to be connected", false));
}
if (!editor.ps.HasDiffuse() && editor.ps.HasSpecular())
{
Errors.Add(SF_ErrorEntry.Create("Using PBL requires metallic/specular to be connected", false));
}
}
List <SF_Node> dupes = new List <SF_Node>();
SF_Node[] propNodes = cNodes.Where(x => x.IsProperty()).ToArray();
for (int i = 0; i < propNodes.Length; i++)
{
for (int j = i + 1; j < propNodes.Length; j++)
{
string nameA = propNodes[i].property.nameInternal;
string nameB = propNodes[j].property.nameInternal;
if (nameA == nameB)
{
dupes.Add(propNodes[j]);
}
}
}
if (dupes.Count > 0)
{
foreach (SF_Node dupe in dupes)
{
Errors.Add(SF_ErrorEntry.Create("You have property nodes with conflicting internal names. Please rename one of the " + dupe.property.nameInternal + " nodes", dupe, false));
}
}
List <SF_Node> dupesVarname = new List <SF_Node>();
for (int i = 0; i < cNodes.Count; i++)
{
for (int j = i + 1; j < cNodes.Count; j++)
{
string nameAvar = cNodes[i].variableName;
string nameBvar = cNodes[j].variableName;
if (nameAvar == nameBvar && dupes.Contains(cNodes[j]) == false)
{
dupesVarname.Add(cNodes[j]);
}
}
}
if (dupesVarname.Count > 0)
{
foreach (SF_Node dupeVarname in dupesVarname)
{
Errors.Add(SF_ErrorEntry.Create("You have nodes with conflicting variable names. Please rename one of the " + dupeVarname.variableName + " nodes", dupeVarname, false));
}
}
// Make sure you set the shader to double sided
if (!editor.ps.catGeometry.IsDoubleSided() && hasFacingNode)
{
SF_ErrorEntry error = SF_ErrorEntry.Create("You are using the Face Sign node, but your shader isn't double-sided. Click the icon to fix", false);
error.action = () => {
UnityEditor.Undo.RecordObject(editor.ps.catGeometry, "error correction - fix double sided");
editor.ps.catGeometry.cullMode = SFPSC_Geometry.CullMode.DoubleSided;
editor.OnShaderModified(NodeUpdateType.Hard);
};
Errors.Add(error);
}
// Check if there are any textures in the vertex input
texturesInVertShader = HasNodeInput <SFN_Tex2d>(editor.mainNode.vertexOffset) || HasNodeInput <SFN_Tex2d>(editor.mainNode.outlineWidth);
viewDirectionInVertOffset = HasNodeInput <SFN_ViewVector>(editor.mainNode.vertexOffset);
editor.shaderEvaluator.RemoveGhostNodes();
if (foundMipUsed)
{
//if( !mipInputUsed ) // This should be fixed with #pragma glsl
// errors.Add( new SF_ErrorEntry( "MIP input is only supported in Direct X", mipNode ) );
mipInputUsed = true;
}
else
{
mipInputUsed = false;
}
int errorCount = Errors.Count(x => !x.isWarning); // Let it compile, even though it has warnings
if (errorCount == 0)
{
return(true);
}
//DisplayErrors();
return(false);
}
public int OnLocalGUI(int yOffset, int in_maxWidth)
{
if (Event.current.type == EventType.Repaint)
{
currentScrollWidth = Mathf.Lerp(currentScrollWidth, targetScrollWidth, 0.3f);
}
this.maxWidth = in_maxWidth;
Rect scrollRectPos = new Rect(0f, yOffset, in_maxWidth, Screen.height / EditorGUIUtility.pixelsPerPoint - yOffset - 20);
bool useScrollbar = (innerScrollRect.height > scrollRectPos.height);
targetScrollWidth = useScrollbar ? 15 : 0;
int scrollBarWidth = (int)currentScrollWidth;
innerScrollRect.width = in_maxWidth - scrollBarWidth;
guiChanged = false;
int offset = 0;
if (innerScrollRect.height < scrollRectPos.height)
{
innerScrollRect.height = scrollRectPos.height;
}
this.maxWidth -= scrollBarWidth;
int scrollPad = scrollBarWidth - 15;
GUI.BeginGroup(scrollRectPos);
Rect scrollWrapper = scrollRectPos;
scrollWrapper.x = 0;
scrollWrapper.y = 0; // Since it's grouped
scrollPos = GUI.BeginScrollView(scrollWrapper.PadRight(scrollPad), scrollPos, innerScrollRect, false, true);
{
//offset = SettingsMeta( 0 );
bool showErrors = editor.nodeView.treeStatus.Errors.Count > 0;
if (!showErrors)
{
catConsole.expanded = false;
}
EditorGUI.BeginDisabledGroup(!showErrors);
offset = catConsole.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
EditorGUI.EndDisabledGroup();
offset = catMeta.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
offset = catProperties.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
offset = catLighting.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
offset = catGeometry.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
offset = catBlending.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
offset = catExperimental.Draw(offset);
offset = GUISeparator(offset); // ----------------------------------------------
}
GUI.EndScrollView();
GUI.EndGroup();
this.maxWidth += scrollBarWidth;
if (guiChanged)
{
editor.ps = this;
editor.OnShaderModified(NodeUpdateType.Hard);
}
innerScrollRect.height = offset;
return(offset);
}