/// <summary>
/// Create a copy of a Shader program using same source but linked in another new program instance.
/// </summary>
/// <param name="copyTarget">
/// The shader to derive a new instance from.
/// </param>
/// <param name="link">
/// If the shader copy is to be linked
/// </param>
/// <returns></returns>
public static ComposedShader CreateNewInstance(ComposedShader copyTarget, bool link = true)
{
ComposedShader derived;
ShaderPart partClone;
derived = new ComposedShader();
derived.language = copyTarget.language;
derived.IsBuiltIn = copyTarget.IsBuiltIn;
foreach (ShaderPart part in copyTarget.ShaderParts)
{
partClone = new ShaderPart();
partClone.ShaderSource = part.ShaderSource;
partClone.Type = part.Type;
derived.ShaderParts.Add(partClone);
}
if (link)
{
derived.Link();
}
return(derived);
}
public void add(LuaTable table)
{
var sp = new ShaderPart();
sp.type = table["type"] as string;
sp.className = table["class"] as string;
sp.source = table["source"] as string;
if (sp.type == null)
{
throw new InvalidShaderException("Shader is missing a type declaration");
}
if (sp.source == null)
{
throw new InvalidShaderException("Shader is missing a source declaration");
}
foreach (string k in table.Keys)
{
if (k == "type" || k == "class" || k == "source")
{
continue;
}
sp.properties[k] = table[k] as string;
}
shader.parts.Add(sp);
}
/// <summary>
/// Deletes a shader part.
/// </summary>
/// <param name="shaderPart">The shader part to delete.</param>
internal static void DeleteShader(ShaderPart shaderPart)
{
//todo: don't use scheduler
resetScheduler.Add(() =>
{
GL.DeleteShader(shaderPart);
});
}
//-------------Draw Functions----------------
private static void testAltClick(Rect rect, ShaderPart property)
{
if (input.HadMouseDownRepaint && input.is_alt_down && rect.Contains(input.mouse_position))
{
if (property.options.altClick != null)
{
property.options.altClick.Perform();
}
}
}
//-------------Draw Functions----------------
private static void testAltClick(Rect rect, ShaderPart property)
{
var e = Event.current;
if (HadMouseDownRepaint && e.alt && rect.Contains(e.mousePosition))
{
if (property.options.altClick != null)
{
property.options.altClick.Perform();
}
}
}
private void CompileIfNecessary(ref ShaderFragment fragment, string header, string @class, ShaderType type)
{
// No compilation needed
if (fragment != null)
{
return;
}
string typeName = GetShaderName(type);
ShaderPart source = null;
foreach (var sp in this.parts)
{
if (sp.type != typeName)
{
continue;
}
if (sp.className != @class)
{
continue;
}
source = sp;
break;
}
if (source == null)
{
// Search for default shader
foreach (var sp in this.parts)
{
if (sp.type != typeName)
{
continue;
}
if (sp.className != null)
{
continue;
}
source = sp;
break;
}
}
if (source == null)
{
return; // No source found, no shader available
}
string input = "";
input = GetInput(source.properties["input"]);
fragment = new ShaderFragment(type, header + input + source.source);
}
/// <summary>
/// Deletes a shader part.
/// </summary>
/// <param name="shaderPart">The shader part to delete.</param>
internal static void DeleteShader(ShaderPart shaderPart)
{
if (!HasContext)
{
return;
}
resetScheduler.Add(() =>
{
GL.DeleteShader(shaderPart);
});
}
//function to handle the drawing of header or property
void drawShaderPart(ShaderPart part, MaterialEditor materialEditor)
{
if (part is ShaderHeader)
{
ShaderHeader header = (ShaderHeader)part;
drawShaderHeader(header, materialEditor);
}
else
{
ShaderProperty property = (ShaderProperty)part;
drawShaderProperty(property, materialEditor);
}
}
//-------------Draw Functions----------------
private static void testAltClick(Rect rect, ShaderPart property)
{
var e = Event.current;
if (isMouseClick && e.alt && rect.Contains(e.mousePosition))
{
if (property.altClick != "")
{
if (property.altClick.StartsWith("url:"))
{
Application.OpenURL(property.altClick.Replace("url:", ""));
}
}
}
}
public static int ApplyShaderPart(int shaderProgramHandle, ShaderPart part)
{
ShaderType type = ShaderType.VertexShader;
switch (part.Type)
{
case shaderPartTypeValues.VERTEX:
type = ShaderType.VertexShader;
break;
case shaderPartTypeValues.FRAGMENT:
type = ShaderType.FragmentShader;
break;
case shaderPartTypeValues.TESS_CONTROL:
type = ShaderType.TessControlShader;
break;
case shaderPartTypeValues.TESS_EVAL:
type = ShaderType.TessEvaluationShader;
break;
case shaderPartTypeValues.GEOMETRY:
type = ShaderType.GeometryShader;
break;
default:
throw new Exception("unknown shader type");
}
part.ShaderHandle = GL.CreateShader(type);
GL.ShaderSource(part.ShaderHandle, part.ShaderSource);
GL.CompileShader(part.ShaderHandle);
string err = GL.GetShaderInfoLog(part.ShaderHandle).Trim();
if (!string.IsNullOrEmpty(err))
{
Console.WriteLine(err);
}
GL.AttachShader(shaderProgramHandle, part.ShaderHandle);
Console.WriteLine("ShaderPart {0} [attaching]", part.Type);
return(part.ShaderHandle);
}
public void addDefault(string name)
{
var sp = new ShaderPart();
switch (name)
{
case "vertex":
this.include("transform");
sp.type = "vertex";
sp.source = Resource.GetString("OpenWorld.Engine.Resources.Shaders.Defaults.vertex");
sp.properties["input"] = "mesh";
break;
case "fragment":
this.include("mesh");
sp.type = "vertex";
sp.source = Resource.GetString("OpenWorld.Engine.Resources.Shaders.Defaults.fragment");
break;
default:
throw new InvalidOperationException("Failed to add default shader: " + name + " is not a valid default shader!");
}
shader.parts.Add(sp);
}
/// <summary>
/// Deletes a shader part.
/// </summary>
/// <param name="shaderPart">The shader part to delete.</param>
internal static void DeleteShader(ShaderPart shaderPart)
{
//todo: don't use scheduler
ScheduleDisposal(() => { GL.DeleteShader(shaderPart); });
}
public void addPart(ShaderPart part)
{
parts.Add(part);
}
private bool IsSearchedFor(ShaderPart part, string term)
{
string lowercaseTerm = header_search_term.ToLower();
return(part.content.text.ToLower().Contains(lowercaseTerm));
}
//finds all properties and headers and stores them in correct order
private void CollectAllProperties()
{
//load display names from file if it exists
MaterialProperty[] props = current.properties;
Dictionary <string, string> labels = LoadDisplayNamesFromFile();
LoadLocales();
current.propertyDictionary = new Dictionary <string, ShaderProperty>();
current.shaderParts = new List <ShaderPart>();
shaderparts = new ShaderHeader(); //init top object that all Shader Objects are childs of
Stack <ShaderGroup> headerStack = new Stack <ShaderGroup>(); //header stack. used to keep track if current header to parent new objects to
headerStack.Push(shaderparts); //add top object as top object to stack
headerStack.Push(shaderparts); //add top object a second time, because it get's popped with first actual header item
footer = new List <ButtonData>(); //init footer list
int headerCount = 0;
Type materialPropertyDrawerType = typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.MaterialPropertyHandler");
MethodInfo getPropertyHandlerMethod = materialPropertyDrawerType.GetMethod("GetShaderPropertyHandler", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
PropertyInfo drawerProperty = materialPropertyDrawerType.GetProperty("propertyDrawer");
Type materialToggleDrawerType = typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.MaterialToggleDrawer");
FieldInfo keyWordField = materialToggleDrawerType.GetField("keyword", BindingFlags.Instance | BindingFlags.NonPublic);
for (int i = 0; i < props.Length; i++)
{
string displayName = props[i].displayName;
if (locale != null)
{
foreach (string key in locale.GetAllKeys())
{
if (displayName.Contains("locale::" + key))
{
displayName = displayName.Replace("locale::" + key, locale.Get(key));
}
}
}
displayName = Regex.Replace(displayName, @"''", "\"");
if (labels.ContainsKey(props[i].name))
{
displayName = labels[props[i].name];
}
PropertyOptions options = ExtractExtraOptionsFromDisplayName(ref displayName);
int offset = options.offset + headerCount;
//Handle keywords
object propertyHandler = getPropertyHandlerMethod.Invoke(null, new object[] { current.shader, props[i].name });
//if has custom drawer
if (propertyHandler != null)
{
object propertyDrawer = drawerProperty.GetValue(propertyHandler, null);
//if custom drawer exists
if (propertyDrawer != null)
{
if (propertyDrawer.GetType().ToString() == "UnityEditor.MaterialToggleDrawer")
{
object keyword = keyWordField.GetValue(propertyDrawer);
if (keyword != null)
{
foreach (Material m in current.materials)
{
if (m.GetFloat(props[i].name) == 1)
{
m.EnableKeyword((string)keyword);
}
else
{
m.DisableKeyword((string)keyword);
}
}
}
}
}
}
ThryPropertyType type = GetPropertyType(props[i], options);
switch (type)
{
case ThryPropertyType.header:
headerStack.Pop();
break;
case ThryPropertyType.header_start:
offset = options.offset + ++headerCount;
break;
case ThryPropertyType.header_end:
headerStack.Pop();
headerCount--;
break;
case ThryPropertyType.on_swap_to:
on_swap_to_actions = options.actions;
break;
}
ShaderProperty newPorperty = null;
ShaderPart newPart = null;
switch (type)
{
case ThryPropertyType.master_label:
masterLabelText = displayName;
break;
case ThryPropertyType.footer:
footer.Add(Parser.ParseToObject <ButtonData>(displayName));
break;
case ThryPropertyType.header:
case ThryPropertyType.header_start:
ShaderHeader newHeader = new ShaderHeader(props[i], current.editor, displayName, offset, options);
headerStack.Peek().addPart(newHeader);
headerStack.Push(newHeader);
HeaderHider.InitHidden(newHeader);
newPart = newHeader;
break;
case ThryPropertyType.group_start:
ShaderGroup new_group = new ShaderGroup(options);
headerStack.Peek().addPart(new_group);
headerStack.Push(new_group);
newPart = new_group;
break;
case ThryPropertyType.group_end:
headerStack.Pop();
break;
case ThryPropertyType.none:
case ThryPropertyType.property:
DrawingData.lastPropertyUsedCustomDrawer = false;
current.editor.GetPropertyHeight(props[i]);
bool forceOneLine = props[i].type == MaterialProperty.PropType.Vector && !DrawingData.lastPropertyUsedCustomDrawer;
if (props[i].type == MaterialProperty.PropType.Texture)
{
newPorperty = new TextureProperty(props[i], displayName, offset, options, props[i].flags.HasFlag(MaterialProperty.PropFlags.NoScaleOffset) == false, !DrawingData.lastPropertyUsedCustomDrawer);
}
else
{
newPorperty = new ShaderProperty(props[i], displayName, offset, options, forceOneLine);
}
break;
case ThryPropertyType.lightmap_flags:
newPorperty = new GIProperty(props[i], displayName, offset, options, false);
break;
case ThryPropertyType.dsgi:
newPorperty = new DSGIProperty(props[i], displayName, offset, options, false);
break;
case ThryPropertyType.instancing:
newPorperty = new InstancingProperty(props[i], displayName, offset, options, false);
break;
case ThryPropertyType.locale:
newPorperty = new LocaleProperty(props[i], displayName, offset, options, false);
break;
}
if (newPorperty != null)
{
newPart = newPorperty;
if (current.propertyDictionary.ContainsKey(props[i].name))
{
continue;
}
current.propertyDictionary.Add(props[i].name, newPorperty);
if (type != ThryPropertyType.none)
{
headerStack.Peek().addPart(newPorperty);
}
}
if (newPart != null)
{
current.shaderParts.Add(newPart);
}
}
}
