bool GenerateUberShader(ICollection <INode> errNodes, out GenerationResults results)
{
ShaderUtil.ClearCachedData(m_UberShader);
results = m_Graph.GetUberColorShader(errNodes);
m_OutputIdName = results.outputIdProperty.referenceName;
ShaderUtil.UpdateShaderAsset(m_UberShader, results.shader);
return(ShaderUtil.ShaderHasError(m_UberShader));
}
void UpdateShaders()
{
// Check for shaders that finished compiling and set them to redraw
foreach (var renderData in m_RenderDatas)
{
if (renderData != null && renderData.shaderData.isCompiling &&
ShaderUtil.IsPassCompiled(renderData.shaderData.mat, 0))
{
renderData.shaderData.isCompiling = false;
CheckForErrors(renderData.shaderData);
m_NodesToDraw.Add(renderData.shaderData.node);
var masterNode = renderData.shaderData.node as IMasterNode;
masterNode?.ProcessPreviewMaterial(renderData.shaderData.mat);
}
}
if (m_NodesToUpdate.Count == 0)
{
return;
}
PropagateNodeList(m_NodesToUpdate, PropagationDirection.Downstream);
// Reset error states for the UI, the shader, and all render data for nodes we're updating
m_Messenger.ClearNodesFromProvider(this, m_NodesToUpdate);
var wasAsyncAllowed = ShaderUtil.allowAsyncCompilation;
ShaderUtil.allowAsyncCompilation = true;
foreach (var node in m_NodesToUpdate)
{
if (node is IMasterNode && node == masterRenderData.shaderData.node)
{
UpdateMasterNodeShader();
continue;
}
if (!node.hasPreview && !(node is SubGraphOutputNode))
{
continue;
}
var results = m_Graph.GetPreviewShader(node);
var renderData = GetRenderData(node.tempId);
if (renderData == null)
{
continue;
}
ShaderUtil.ClearCachedData(renderData.shaderData.shader);
// Always explicitly use pass 0 for preview shaders
BeginCompile(renderData, results.shader, 0);
}
ShaderUtil.allowAsyncCompilation = wasAsyncAllowed;
m_NodesToUpdate.Clear();
}
void BeginCompile(PreviewRenderData renderData, string shaderStr)
{
var shaderData = renderData.shaderData;
ShaderUtil.ClearCachedData(shaderData.shader);
ShaderUtil.UpdateShaderAsset(shaderData.shader, shaderStr, false);
for (var i = 0; i < shaderData.mat.passCount; i++)
{
ShaderUtil.CompilePass(shaderData.mat, i);
}
shaderData.isCompiling = true;
renderData.NotifyPreviewChanged();
}
void UpdateMasterNodeShader()
{
var shaderData = masterRenderData?.shaderData;
var masterNode = shaderData?.node as IMasterNode;
if (masterNode == null)
{
return;
}
List <PropertyCollector.TextureInfo> configuredTextures;
shaderData.shaderString = masterNode.GetShader(GenerationMode.Preview, shaderData.node.name, out configuredTextures);
if (string.IsNullOrEmpty(shaderData.shaderString))
{
if (shaderData.shader != null)
{
ShaderUtil.ClearShaderMessages(shaderData.shader);
Object.DestroyImmediate(shaderData.shader, true);
shaderData.shader = null;
}
return;
}
if (shaderData.shader == null)
{
shaderData.shader = ShaderUtil.CreateShaderAsset(shaderData.shaderString, false);
shaderData.shader.hideFlags = HideFlags.HideAndDontSave;
}
else
{
ShaderUtil.ClearCachedData(shaderData.shader);
}
BeginCompile(masterRenderData, shaderData.shaderString, masterNode.GetActiveSubShader()?.GetPreviewPassIndex() ?? 0);
}
void UpdateMasterNodeShader()
{
var shaderData = masterRenderData?.shaderData;
var masterNode = shaderData?.node as IMasterNode;
if (masterNode == null)
{
return;
}
var generator = new Generator(m_Graph, shaderData?.node, GenerationMode.Preview, shaderData?.node.name);
shaderData.shaderString = generator.generatedShader;
if (string.IsNullOrEmpty(shaderData.shaderString))
{
if (shaderData.shader != null)
{
ShaderUtil.ClearShaderMessages(shaderData.shader);
Object.DestroyImmediate(shaderData.shader, true);
shaderData.shader = null;
}
return;
}
if (shaderData.shader == null)
{
shaderData.shader = ShaderUtil.CreateShaderAsset(shaderData.shaderString, false);
shaderData.shader.hideFlags = HideFlags.HideAndDontSave;
}
else
{
ShaderUtil.ClearCachedData(shaderData.shader);
}
BeginCompile(masterRenderData, shaderData.shaderString);
}
void BeginCompile(PreviewRenderData renderData, string shaderStr)
{
using (BeginCompileMarker.Auto())
{
var shaderData = renderData.shaderData;
// want to ensure this so we don't get confused with multiple compile versions in flight
Assert.IsTrue(shaderData.passesCompiling == 0);
if (shaderData.shader == null)
{
shaderData.shader = ShaderUtil.CreateShaderAsset(shaderStr, false);
shaderData.shader.hideFlags = HideFlags.HideAndDontSave;
}
else
{
ShaderUtil.ClearCachedData(shaderData.shader);
ShaderUtil.UpdateShaderAsset(shaderData.shader, shaderStr, false);
}
if (shaderData.mat == null)
{
shaderData.mat = new Material(shaderData.shader)
{
hideFlags = HideFlags.HideAndDontSave
};
}
shaderData.passesCompiling = shaderData.mat.passCount;
for (var i = 0; i < shaderData.mat.passCount; i++)
{
ShaderUtil.CompilePass(shaderData.mat, i);
}
m_NodesCompiling.Add(shaderData.node);
}
}
void UpdateShaders()
{
// Check for shaders that finished compiling and set them to redraw
foreach (var renderData in m_RenderDatas)
{
if (renderData != null && renderData.shaderData.isCompiling)
{
var isCompiled = true;
for (var i = 0; i < renderData.shaderData.mat.passCount; i++)
{
if (!ShaderUtil.IsPassCompiled(renderData.shaderData.mat, i))
{
isCompiled = false;
break;
}
}
if (!isCompiled)
{
continue;
}
// Force the material to re-generate all it's shader properties.
renderData.shaderData.mat.shader = renderData.shaderData.shader;
renderData.shaderData.isCompiling = false;
CheckForErrors(renderData.shaderData);
m_NodesToDraw.Add(renderData.shaderData.node);
var masterNode = renderData.shaderData.node as IMasterNode;
masterNode?.ProcessPreviewMaterial(renderData.shaderData.mat);
}
}
if (m_NodesToUpdate.Count == 0)
{
return;
}
PropagateNodeList(m_NodesToUpdate, PropagationDirection.Downstream);
// Reset error states for the UI, the shader, and all render data for nodes we're updating
m_Messenger.ClearNodesFromProvider(this, m_NodesToUpdate);
var wasAsyncAllowed = ShaderUtil.allowAsyncCompilation;
ShaderUtil.allowAsyncCompilation = true;
foreach (var node in m_NodesToUpdate)
{
if (node is IMasterNode && node == masterRenderData.shaderData.node && !(node is VfxMasterNode))
{
UpdateMasterNodeShader();
continue;
}
if (!node.hasPreview && !(node is SubGraphOutputNode || node is VfxMasterNode))
{
continue;
}
var results = m_Graph.GetPreviewShader(node);
var renderData = GetRenderData(node.tempId);
if (renderData == null)
{
continue;
}
ShaderUtil.ClearCachedData(renderData.shaderData.shader);
BeginCompile(renderData, results.shader);
//get the preview mode from generated results
renderData.previewMode = results.previewMode;
}
ShaderUtil.allowAsyncCompilation = wasAsyncAllowed;
m_NodesToUpdate.Clear();
}
void UpdateMasterNodeShader(Identifier nodeId)
{
var masterNode = m_Graph.GetNodeFromTempId(nodeId) as IMasterNode;
var renderData = Get(m_RenderDatas, nodeId);
var shaderData = renderData?.shaderData;
if (masterNode == null || shaderData == null)
{
return;
}
List <PropertyCollector.TextureInfo> configuredTextures;
shaderData.shaderString = masterNode.GetShader(GenerationMode.Preview, masterNode.name, out configuredTextures);
var debugOutputPath = DefaultShaderIncludes.GetDebugOutputPath();
if (!string.IsNullOrEmpty(debugOutputPath))
{
File.WriteAllText(debugOutputPath + "/GeneratedShader.shader",
(shaderData.shaderString ?? "null").Replace("UnityEngine.MaterialGraph", "Generated"));
}
if (string.IsNullOrEmpty(shaderData.shaderString))
{
if (shaderData.shader != null)
{
ShaderUtil.ClearShaderMessages(shaderData.shader);
Object.DestroyImmediate(shaderData.shader, true);
shaderData.shader = null;
}
return;
}
if (shaderData.shader == null)
{
shaderData.shader = ShaderUtil.CreateShaderAsset(shaderData.shaderString);
shaderData.shader.hideFlags = HideFlags.HideAndDontSave;
}
else
{
ShaderUtil.ClearCachedData(shaderData.shader);
ShaderUtil.UpdateShaderAsset(shaderData.shader, shaderData.shaderString);
}
// Debug output
shaderData.hasError = ShaderUtil.ShaderHasError(shaderData.shader);
if (shaderData.hasError)
{
var messages = ShaderUtil.GetShaderMessages(shaderData.shader);
foreach (var message in messages)
{
Debug.LogFormat("Compilation error in {3} at line {1} (on {2}):\n{0}", message.message,
message.line, message.platform, "graph");
}
if (!string.IsNullOrEmpty(debugOutputPath))
{
var AMNode = masterNode as AbstractMaterialNode;
var message = "RecreateShader: " + AMNode?.GetVariableNameForNode() + Environment.NewLine + shaderData.shaderString;
Debug.LogWarning(message);
}
ShaderUtil.ClearShaderMessages(shaderData.shader);
Object.DestroyImmediate(shaderData.shader, true);
shaderData.shader = null;
}
}
void UpdateShaders()
{
// Check for shaders that finished compiling and set them to redraw
foreach (var renderData in m_RenderDatas.Values)
{
if (renderData.shaderData.isCompiling)
{
var isCompiled = true;
for (var i = 0; i < renderData.shaderData.mat.passCount; i++)
{
if (!ShaderUtil.IsPassCompiled(renderData.shaderData.mat, i))
{
isCompiled = false;
break;
}
}
if (!isCompiled)
{
continue;
}
// Force the material to re-generate all it's shader properties.
renderData.shaderData.mat.shader = renderData.shaderData.shader;
renderData.shaderData.isCompiling = false;
CheckForErrors(renderData.shaderData);
m_NodesToDraw.Add(renderData.shaderData.node);
var masterNode = renderData.shaderData.node as IMasterNode;
masterNode?.ProcessPreviewMaterial(renderData.shaderData.mat);
}
}
if (m_NodesToUpdate.Count == 0)
{
return;
}
PropagateNodeList(m_NodesToUpdate, PropagationDirection.Downstream);
// Reset error states for the UI, the shader, and all render data for nodes we're updating
m_Messenger.ClearNodesFromProvider(this, m_NodesToUpdate);
var wasAsyncAllowed = ShaderUtil.allowAsyncCompilation;
ShaderUtil.allowAsyncCompilation = true;
foreach (var node in m_NodesToUpdate)
{
if (node is IMasterNode && node == masterRenderData.shaderData.node && !(node is VfxMasterNode))
{
UpdateMasterNodeShader();
continue;
}
if (!node.hasPreview && !(node is SubGraphOutputNode || node is VfxMasterNode))
{
continue;
}
var renderData = m_RenderDatas[node.guid];
if (renderData == null)
{
continue;
}
ShaderUtil.ClearCachedData(renderData.shaderData.shader);
// Get shader code and compile
var generator = new Generator(node.owner, node, GenerationMode.Preview, $"hidden/preview/{node.GetVariableNameForNode()}");
BeginCompile(renderData, generator.generatedShader);
// Calculate the PreviewMode from upstream nodes
// If any upstream node is 3D that trickles downstream
List <AbstractMaterialNode> upstreamNodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(upstreamNodes, node, NodeUtils.IncludeSelf.Include);
renderData.previewMode = PreviewMode.Preview2D;
foreach (var pNode in upstreamNodes)
{
if (pNode.previewMode == PreviewMode.Preview3D)
{
renderData.previewMode = PreviewMode.Preview3D;
break;
}
}
}
ShaderUtil.allowAsyncCompilation = wasAsyncAllowed;
m_NodesToUpdate.Clear();
}
