public string Compile(string[] features, string name, string baseName = null, AuxShader auxShader = null)
{
try
{
EditorUtility.DisplayProgressBar("Compiling Shaders", "...", 0.5f);
Init();
// get default render loop if it doesn't exist
if (renderLoop == null)
{
for (int i = 0; i < availableRenderLoops.Count; ++i)
{
if (availableRenderLoops [i].GetType() == typeof(SurfaceShaderRenderLoopAdapter))
{
renderLoop = availableRenderLoops [i];
}
}
}
// TODO: this would be better if we asked the render loop if it is in the feature list, but
// would require a change to interface, so wait until we have a version bump.
SetPreferedRenderLoopByName(features, "_MSRENDERLOOP_UNITYLD");
SetPreferedRenderLoopByName(features, "_MSRENDERLOOP_UNITYHD");
#if UNITY_2020_2_OR_NEWER
SetPreferedRenderLoopByName(features, "_MSRENDERLOOP_UNITYURP2020");
SetPreferedRenderLoopByName(features, "_MSRENDERLOOP_UNITYHDRP2020");
#endif
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
ext.Unpack(features);
}
StringBuilder sb = renderLoop.WriteShader(features, this, auxShader, name, baseName);
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
ext.OnPostGeneration(ref sb, features, name, baseName, auxShader);
}
string output = sb.ToString();
// fix newline mixing warnings..
output = System.Text.RegularExpressions.Regex.Replace(output, "\r\n?|\n", System.Environment.NewLine);
EditorUtility.ClearProgressBar();
return(output);
}
catch
{
EditorUtility.ClearProgressBar();
return("");
}
}
void SetPreferedRenderLoopByName(string[] features, string keyword)
{
if (!features.Contains (keyword))
return;
for (int i = 0; i < availableRenderLoops.Count; ++i)
{
if (availableRenderLoops [i].GetRenderLoopKeyword() == keyword)
{
renderLoop = availableRenderLoops [i];
}
}
}
public void Init ()
{
if (extensions.Count == 0)
{
string[] paths = AssetDatabase.FindAssets ("microsplat_ t:TextAsset");
for (int i = 0; i < paths.Length; ++i)
{
paths [i] = AssetDatabase.GUIDToAssetPath (paths [i]);
}
// init extensions
var types = System.Reflection.Assembly.GetExecutingAssembly ().GetTypes ();
var possible = (from System.Type type in types
where type.IsSubclassOf (typeof(FeatureDescriptor))
select type).ToArray ();
for (int i = 0; i < possible.Length; ++i)
{
var typ = possible [i];
FeatureDescriptor ext = System.Activator.CreateInstance (typ) as FeatureDescriptor;
ext.InitCompiler (paths);
extensions.Add (ext);
}
extensions.Sort (delegate (FeatureDescriptor p1, FeatureDescriptor p2)
{
if (p1.DisplaySortOrder () != 0 || p2.DisplaySortOrder () != 0)
{
return p1.DisplaySortOrder ().CompareTo (p2.DisplaySortOrder ());
}
return p1.GetType ().Name.CompareTo (p2.GetType ().Name);
});
var adapters = (from System.Type type in types
where (type.GetInterfaces ().Contains (typeof(IRenderLoopAdapter)))
select type).ToArray ();
availableRenderLoops.Clear ();
for (int i = 0; i < adapters.Length; ++i)
{
var typ = adapters [i];
IRenderLoopAdapter adapter = System.Activator.CreateInstance (typ) as IRenderLoopAdapter;
adapter.Init (paths);
availableRenderLoops.Add (adapter);
}
}
}
public string Compile(string[] features, string name, string baseName = null, bool blendable = false)
{
Init();
// get default render loop if it doesn't exist
if (renderLoop == null)
{
for (int i = 0; i < availableRenderLoops.Count; ++i)
{
if (availableRenderLoops [i].GetType() == typeof(SurfaceShaderRenderLoopAdapter))
{
renderLoop = availableRenderLoops [i];
}
}
}
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
ext.Unpack(features);
}
sBuilder.Length = 0;
var sb = sBuilder;
sb.AppendLine("//////////////////////////////////////////////////////");
sb.AppendLine("// MicroSplat");
sb.AppendLine("// Copyright (c) Jason Booth");
sb.AppendLine("//");
sb.AppendLine("// Auto-generated shader code, don't hand edit!");
sb.AppendLine("// Compiled with MicroSplat " + MicroSplatVersion);
sb.AppendLine("// Unity : " + Application.unityVersion);
sb.AppendLine("// Platform : " + Application.platform);
if (renderLoop != null)
{
sb.AppendLine("// RenderLoop : " + renderLoop.GetDisplayName());
}
sb.AppendLine("//////////////////////////////////////////////////////");
sb.AppendLine();
if (!blendable && baseName == null)
{
sb.Append("Shader \"Hidden/MicroSplat/");
}
else
{
sb.Append("Shader \"MicroSplat/");
}
while (name.Contains("/"))
{
name = name.Substring(name.IndexOf("/") + 1);
}
sb.Append(name);
if (blendable)
{
if (features.Contains("_MESHOVERLAYSPLATS"))
{
sb.Append("_MeshOverlay");
}
else
{
sb.Append("_BlendWithTerrain");
}
}
sb.AppendLine("\" {");
// props
WriteProperties(features, sb, blendable);
renderLoop.WriteShaderHeader(features, sb, this, blendable);
for (int pass = 0; pass < renderLoop.GetNumPasses(); ++pass)
{
renderLoop.WritePassHeader(features, sb, this, pass, blendable);
// don't remove
sb.AppendLine();
sb.AppendLine();
if (renderLoop.UseReplaceMethods() == false)
{
WriteFeatures(features, sb);
if (renderLoop == null)
{
sb.AppendLine(" #define _MSRENDERLOOP_SURFACESHADER 1");
}
else
{
sb.AppendLine(" #define " + renderLoop.GetRenderLoopKeyword() + " 1");
}
if (blendable)
{
if (features.Contains("_MESHOVERLAYSPLATS"))
{
sb.AppendLine(" #define _MESHOVERLAYSPLATSSHADER 1");
}
else
{
sb.AppendLine(" #define _TERRAINBLENDABLESHADER 1");
}
}
}
// HDRP/URP uses CBuffers, everything else just inlines..
if (renderLoop.UseReplaceMethods() == false)
{
renderLoop.WritePerMaterialCBuffer(features, sb, blendable);
WritePerMaterialCBuffer(features, sb);
}
renderLoop.WriteSharedCode(features, sb, this, pass, blendable);
passType = renderLoop.GetPassType(pass);
if (renderLoop.UseReplaceMethods() == false)
{
WriteExtensions(features, sb);
renderLoop.WriteVertexFunction(features, sb, this, pass, blendable);
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
if (ext.GetVersion() == MicroSplatVersion)
{
extensions [i].WriteAfterVetrexFunctions(sb);
}
}
}
renderLoop.WriteTerrainBody(features, sb, this, pass, blendable);
renderLoop.WriteFragmentFunction(features, sb, this, pass, blendable);
}
renderLoop.WriteShaderFooter(features, sb, this, blendable, baseName);
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
ext.OnPostGeneration(sb, features, name, baseName, blendable);
}
sb.AppendLine("");
renderLoop.PostProcessShader(features, sb, this, blendable);
string output = sb.ToString();
// fix newline mixing warnings..
output = System.Text.RegularExpressions.Regex.Replace(output, "\r\n?|\n", System.Environment.NewLine);
return(output);
}
public string Compile(string[] features, string name, string baseName = null, AuxShader auxShader = null)
{
try
{
EditorUtility.DisplayProgressBar("Compiling Shaders", "...", 0.5f);
Init();
// get default render loop if it doesn't exist
if (renderLoop == null)
{
for (int i = 0; i < availableRenderLoops.Count; ++i)
{
if (availableRenderLoops [i].GetType() == typeof(SurfaceShaderRenderLoopAdapter))
{
renderLoop = availableRenderLoops [i];
}
}
}
// TODO: this would be better if we asked the render loop if it is in the feature list, but
// would require a change to interface, so wait until we have a version bump.
SetPreferedRenderLoopByName(features, "_MSRENDERLOOP_UNITYLD");
SetPreferedRenderLoopByName(features, "_MSRENDERLOOP_UNITYHD");
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
ext.Unpack(features);
}
sBuilder.Length = 0;
var sb = sBuilder;
sb.AppendLine("//////////////////////////////////////////////////////");
sb.AppendLine("// MicroSplat");
sb.AppendLine("// Copyright (c) Jason Booth");
sb.AppendLine("//");
sb.AppendLine("// Auto-generated shader code, don't hand edit!");
sb.AppendLine("// Compiled with MicroSplat " + MicroSplatVersion);
sb.AppendLine("// Unity : " + Application.unityVersion);
sb.AppendLine("// Platform : " + Application.platform);
if (renderLoop != null)
{
sb.AppendLine("// RenderLoop : " + renderLoop.GetDisplayName());
}
sb.AppendLine("//////////////////////////////////////////////////////");
sb.AppendLine();
if (auxShader == null && baseName == null)
{
sb.Append("Shader \"Hidden/MicroSplat/");
}
else
{
sb.Append("Shader \"MicroSplat/");
}
while (name.Contains("/"))
{
name = name.Substring(name.IndexOf("/") + 1);
}
sb.Append(name);
if (auxShader != null)
{
sb.Append(auxShader.extension);
}
sb.AppendLine("\" {");
// props
WriteProperties(features, sb, auxShader);
renderLoop.WriteShaderHeader(features, sb, this, auxShader);
for (int pass = 0; pass < renderLoop.GetNumPasses(); ++pass)
{
renderLoop.WritePassHeader(features, sb, this, pass, auxShader);
// don't remove
sb.AppendLine();
sb.AppendLine();
if (renderLoop.UseReplaceMethods() == false)
{
WriteFeatures(features, sb);
if (renderLoop == null)
{
sb.AppendLine(" #define _MSRENDERLOOP_SURFACESHADER 1");
}
else
{
sb.AppendLine(" #define " + renderLoop.GetRenderLoopKeyword() + " 1");
}
}
// HDRP/URP uses CBuffers, everything else just inlines..
if (renderLoop.UseReplaceMethods() == false)
{
renderLoop.WritePerMaterialCBuffer(features, sb, auxShader);
WritePerMaterialCBuffer(features, sb);
}
renderLoop.WriteSharedCode(features, sb, this, pass, auxShader);
if (renderLoop.UseReplaceMethods() == false)
{
WriteExtensions(features, sb);
renderLoop.WriteVertexFunction(features, sb, this, pass, auxShader);
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
if (ext.GetVersion() == MicroSplatVersion)
{
extensions [i].WriteAfterVetrexFunctions(sb);
}
}
}
renderLoop.WriteTerrainBody(features, sb, this, pass, auxShader);
renderLoop.WriteFragmentFunction(features, sb, this, pass, auxShader);
}
renderLoop.WriteShaderFooter(features, sb, this, auxShader, baseName);
sb.AppendLine("");
renderLoop.PostProcessShader(features, sb, this, auxShader);
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions [i];
ext.OnPostGeneration(ref sb, features, name, baseName, auxShader);
}
string output = sb.ToString();
// fix newline mixing warnings..
output = System.Text.RegularExpressions.Regex.Replace(output, "\r\n?|\n", System.Environment.NewLine);
EditorUtility.ClearProgressBar();
return(output);
}
catch
{
EditorUtility.ClearProgressBar();
return("");
}
}
public string Compile(string[] features, string name, string baseName = null, bool blendable = false)
{
Init();
// get default render loop if it doesn't exist
if (renderLoop == null)
{
for (int i = 0; i < availableRenderLoops.Count; ++i)
{
if (availableRenderLoops[i].GetType() == typeof(SurfaceShaderRenderLoopAdapter))
{
renderLoop = availableRenderLoops[i];
}
}
}
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions[i];
ext.Unpack(features);
}
sBuilder.Length = 0;
var sb = sBuilder;
sb.AppendLine("//////////////////////////////////////////////////////");
sb.AppendLine("// MicroSplat");
sb.AppendLine("// Copyright (c) Jason Booth");
sb.AppendLine("//");
sb.AppendLine("// Auto-generated shader code, don't hand edit!");
sb.AppendLine("// Compiled with MicroSplat " + MicroSplatVersion);
sb.AppendLine("// Unity : " + Application.unityVersion);
sb.AppendLine("// Platform : " + Application.platform);
sb.AppendLine("//////////////////////////////////////////////////////");
sb.AppendLine();
if (!blendable && baseName == null)
{
sb.Append("Shader \"Hidden/MicroSplat/");
}
else
{
sb.Append("Shader \"MicroSplat/");
}
while (name.Contains("/"))
{
name = name.Substring(name.IndexOf("/") + 1);
}
sb.Append(name);
if (blendable)
{
sb.Append("_BlendWithTerrain");
}
sb.AppendLine("\" {");
// props
WriteProperties(features, sb, blendable);
renderLoop.WriteShaderHeader(features, sb, this, blendable);
for (int pass = 0; pass < renderLoop.GetNumPasses(); ++pass)
{
renderLoop.WritePassHeader(features, sb, this, pass, blendable);
// don't remove
sb.AppendLine();
sb.AppendLine();
WriteFeatures(features, sb);
sb.AppendLine(terrainBody.text);
renderLoop.WriteVertexFunction(features, sb, this, pass, blendable);
renderLoop.WriteFragmentFunction(features, sb, this, pass, blendable);
sb.AppendLine("ENDCG\n\n }");
}
renderLoop.WriteShaderFooter(features, sb, this, blendable, baseName);
for (int i = 0; i < extensions.Count; ++i)
{
var ext = extensions[i];
ext.OnPostGeneration(sb, features, name, baseName, blendable);
}
sb.AppendLine("");
string output = sb.ToString();
// fix newline mixing warnings..
output = System.Text.RegularExpressions.Regex.Replace(output, "\r\n?|\n", System.Environment.NewLine);
return(output);
}
