private IBuilder GetBuilder(Builtin builtin)
{
if (builtin == null)
{
throw new ArgumentNullException("builtin");
}
//获取当前构件的构建器对象
IBuilder builder = builtin.Plugin.GetBuilder(builtin.BuilderName);
if (builder == null)
{
throw new PluginException(string.Format(@"The name is '{0}' of Builder not found in '{1}' plugin." + Environment.NewLine + "{2}", builtin.BuilderName, builtin.Plugin.Name, builtin.Plugin.FilePath));
}
return(builder);
}
/// <summary>
/// Converts a shader resource into a builtin shader.
/// </summary>
/// <param name="shader">Shader resource to convert.</param>
/// <returns>Type of builtin shader, if any.</returns>
private BuiltinShader ShaderToBuiltin(Shader shader)
{
// Note: Need a better way to detect the builtin shader perhaps (store it in Material?)
Shader standardShader = Builtin.GetShader(BuiltinShader.Standard);
Shader transparentShader = Builtin.GetShader(BuiltinShader.Transparent);
; if (standardShader == shader)
{
return(BuiltinShader.Standard);
}
else if (transparentShader == shader)
{
return(BuiltinShader.Transparent);
}
return(BuiltinShader.Custom);
}
/// <summary>
/// Converts a shader resource into a builtin shader.
/// </summary>
/// <param name="shader">Shader resource to convert.</param>
/// <returns>Type of builtin shader, if any.</returns>
private BuiltinShader ShaderToBuiltin(Shader shader)
{
// Note: Might be nice to have a better way to detect the builtin shader perhaps (store it in Material?)
// - Or I could just compare UUID's here to avoid loading the shaders
var enumValues = Enum.GetValues(typeof(BuiltinShader));
for (int i = 1; i < enumValues.Length; i++)
{
Shader builtinShader = Builtin.GetShader((BuiltinShader)i);
if (builtinShader == shader)
{
return((BuiltinShader)i);
}
}
return(BuiltinShader.Custom);
}
private BuilderContext(IBuilder builder, Builtin builtin, object parameter, object owner, PluginTreeNode ownerNode)
{
_builder = builder ?? throw new ArgumentNullException(nameof(builder));
_builtin = builtin ?? throw new ArgumentNullException(nameof(builtin));
_appender = builder as IAppender;
_parameter = parameter;
_owner = owner;
_ownerNode = ownerNode;
if (builtin.HasBehaviors)
{
_cancel = builtin.Behaviors.GetBehaviorValue <bool>(builtin.BuilderName + ".break");
}
_syncRoot = new object();
}
/// <inheritdoc/>
protected internal override void Initialize()
{
Material material = InspectedObject as Material;
if (material == null)
{
return;
}
Shader activeShader = material.Shader;
BuiltinShader builtinType = ShaderToBuiltin(activeShader);
builtinShaderField = new GUIEnumField(typeof(BuiltinShader), new LocEdString("Shader"));
builtinShaderField.Value = (ulong)builtinType;
builtinShaderField.OnSelectionChanged += x =>
{
BuiltinShader newBuiltinType = (BuiltinShader)x;
material.Shader = Builtin.GetShader(newBuiltinType);
EditorApplication.SetDirty(material);
RebuildParamGUI(material);
bool newIsCustom = newBuiltinType == BuiltinShader.Custom;
shaderField.Active = newIsCustom;
};
shaderField = new GUIResourceField(typeof(Shader), new LocEdString("Shader file"));
shaderField.Value = material.Shader;
shaderField.OnChanged += (x) =>
{
Shader shader = Resources.Load <Shader>(x);
material.Shader = shader;
EditorApplication.SetDirty(material);
RebuildParamGUI(material);
};
bool isCustom = builtinType == BuiltinShader.Custom;
shaderField.Active = isCustom;
Layout.AddElement(builtinShaderField);
Layout.AddElement(shaderField);
RebuildParamGUI(material);
}
private void BuildChild(Builtin builtin, object parameter, object owner, PluginTreeNode ownerNode)
{
//获取当前构件的构建器对象
IBuilder builder = this.GetBuilder(builtin);
if (builtin.IsBuilded)
{
if (owner != null && builder is IAppender appender)
{
appender.Append(new AppenderContext(builtin.Context, builtin.Value, builtin.Node, owner, ownerNode, AppenderBehavior.Append));
}
}
else
{
this.BuildCore(builder, BuilderContext.CreateContext(builder, builtin, parameter, owner, ownerNode), null, null);
}
}
public override object Build(BuilderContext context)
{
Builtin builtin = context.Builtin;
IOptionProvider provider = null;
string providerValue = builtin.Properties.GetRawValue("provider");
var node = new OptionNode(builtin.Name,
builtin.Properties.GetValue <string>("title"),
builtin.Properties.GetValue <string>("description"));
if (string.IsNullOrWhiteSpace(providerValue))
{
return(node);
}
switch (providerValue.Trim().ToLower())
{
case ".":
case "plugin":
provider = OptionUtility.GetConfiguration(builtin.Plugin);
break;
case "/":
case "application":
provider = context.PluginContext.ApplicationContext.Configuration;
break;
default:
provider = builtin.Properties.GetValue <IOptionProvider>("provider");
break;
}
if (provider == null)
{
throw new PluginException(string.Format("Cann't obtain OptionProvider with '{0}'.", providerValue));
}
node.Option = new Option(node, provider)
{
View = context.Builtin.Properties.GetValue <IOptionView>("view"),
ViewBuilder = context.Builtin.Properties.GetValue <IOptionViewBuilder>("viewBuilder"),
};
return(node);
}
private BuilderContext(IBuilder builder, Builtin builtin, BuilderSettings settings, int depth, object owner, PluginTreeNode ownerNode)
{
_builder = builder ?? throw new ArgumentNullException(nameof(builder));
_builtin = builtin ?? throw new ArgumentNullException(nameof(builtin));
_appender = builder as IAppender;
_settings = settings;
_depth = depth;
_owner = owner;
_ownerNode = ownerNode;
if (builtin.HasBehaviors)
{
_cancel = builtin.Behaviors.GetBehaviorValue <bool>(builtin.Scheme + ".break");
}
_syncRoot = new object();
}
StoreTyped(OldInstance inst)
{
uint size = (uint)Marshal.SizeOf(typeof(PyInstanceObject));
IntPtr ptr = this.allocator.Alloc(size);
CPyMarshal.Zero(ptr, size);
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1);
CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyInstance_Type);
CPyMarshal.WritePtrField(ptr, typeof(PyInstanceObject), "in_class",
this.Store(Builtin.getattr(this.scratchContext, inst, "__class__")));
CPyMarshal.WritePtrField(ptr, typeof(PyInstanceObject), "in_dict",
this.Store(Builtin.getattr(this.scratchContext, inst, "__dict__")));
this.map.Associate(ptr, inst);
return(ptr);
}
internal ParserContext(string scheme, string text, Builtin builtin, string memberName, Type memberType, object parameter = null)
{
if (string.IsNullOrEmpty(scheme))
{
throw new ArgumentNullException(nameof(scheme));
}
if (builtin == null)
{
throw new ArgumentNullException(nameof(builtin));
}
this.Scheme = scheme;
this.Text = text ?? string.Empty;
this.Parameter = parameter;
this.MemberName = memberName;
this.MemberType = memberType;
this.Node = builtin.Node;
}
public int GetExitCode(out object otherCode) {
otherCode = null;
object pyObj = PythonExceptions.ToPython(this);
object args;
PythonTuple t;
if (!PythonOps.TryGetBoundAttr(pyObj, "args", out args) ||
(t = args as PythonTuple) == null ||
t.__len__() == 0) {
return 0;
} else if (Builtin.isinstance(t[0], TypeCache.Int32)) {
return Converter.ConvertToInt32(t[0]);
}
otherCode = t[0];
return 1;
}
private void OnBuiltinShaderFieldChanged(UInt64 value)
{
Shader activeShader = material.Shader.Value;
BuiltinShader builtinType = ShaderToBuiltin(activeShader);
BuiltinShader newBuiltinType = (BuiltinShader)value;
if (builtinType == newBuiltinType)
{
return;
}
material.Shader = Builtin.GetShader(newBuiltinType);
EditorApplication.SetDirty(material);
RebuildParamGUI(material);
bool newIsCustom = newBuiltinType == BuiltinShader.Custom;
shaderField.Active = newIsCustom;
}
private BuilderContext(Builtin builtin, object parameter, object owner, PluginTreeNode ownerNode)
{
if (builtin == null)
{
throw new ArgumentNullException("builtin");
}
_builtin = builtin;
_parameter = parameter;
_owner = owner;
_ownerNode = ownerNode;
if (builtin.HasBehaviors)
{
_cancel = builtin.Behaviors.GetBehaviorValue <bool>(builtin.BuilderName + ".break");
}
_syncRoot = new object();
}
internal static object ImportLightThrow(CodeContext /*!*/ context, string fullName, PythonTuple from, int level)
{
Debug.Assert(level >= 0);
PythonContext pc = context.LanguageContext;
var site = pc.ImportSite;
return(site.Target(
site,
context,
FindImportFunction(context),
fullName,
Builtin.globals(context),
context.Dict,
from,
level
));
}
public override Type GetValueType(Builtin builtin)
{
//调用基类同名方法
var type = base.GetValueType(builtin);
if (type == null)
{
//尝试获取value属性值的类型
if (builtin.Properties.TryGet("value", out var property) && Parsers.Parser.CanParse(property.RawValue))
{
return(Parsers.Parser.GetValueType(property.RawValue, builtin));
}
//返回所有者元素类型（如果所有者如果是一个泛型集合的话，否则返回空）
return(PluginUtility.GetOwnerElementType(builtin.Node));
}
return(type);
}
StoreTyped(OldClass cls)
{
uint size = (uint)Marshal.SizeOf(typeof(PyClassObject));
IntPtr ptr = this.allocator.Alloc(size);
CPyMarshal.Zero(ptr, size);
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 2); // leak classes deliberately
CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyClass_Type);
CPyMarshal.WritePtrField(ptr, typeof(PyClassObject), "cl_bases",
this.Store(Builtin.getattr(this.scratchContext, cls, "__bases__")));
CPyMarshal.WritePtrField(ptr, typeof(PyClassObject), "cl_dict",
this.Store(Builtin.getattr(this.scratchContext, cls, "__dict__")));
CPyMarshal.WritePtrField(ptr, typeof(PyClassObject), "cl_name",
this.Store(Builtin.getattr(this.scratchContext, cls, "__name__")));
this.map.Associate(ptr, cls);
return(ptr);
}
private Object EvalIdentifier(Identifier identifier, Environment env)
{
Object obj = null;
if (env.TryGetValue(identifier.Value, out obj))
{
return(obj);
}
Builtin builtin = null;
if (Builtins.Functions.TryGetValue(identifier.Value, out builtin))
{
return(builtin);
}
return(new Error()
{
Message = $"Identifier not found: {identifier.Value}"
});
}
/// <summary>
/// used by text
/// </summary>
/// <param name="value">value name</param>
/// <returns></returns>
public Value ResolveValue(string value, ObjectContext ctx)
{
var path = value.Split('.');
var obj = this;
var member = path.First();
if (path.Length > 1)
{
if (Builtin.IsBuiltInVariable(path.First()))
{
obj = Builtin.GetBuiltInVariable(path.First(), ctx).ToObject();
member = path[1];
}
else
{
throw new NotImplementedException();
}
}
return(obj.GetMember(member));
}
public virtual Type GetValueType(Builtin builtin)
{
if (builtin.HasValue)
{
return(builtin.Value.GetType());
}
if (builtin.BuiltinType != null)
{
return(builtin.BuiltinType.Type);
}
var attribute = (BuilderBehaviorAttribute)Attribute.GetCustomAttribute(this.GetType(), typeof(BuilderBehaviorAttribute), true);
if (attribute != null)
{
return(attribute.ValueType);
}
return(null);
}
public void BuiltinTests()
{
// a normal (and best case example)
Assert.IsNotNull(Builtin.Parse(NCS("NUMBER")));
Assert.IsTrue(Builtin.IsValid("NUMBER"));
// other legal (but not always great) examples
Assert.IsNotNull(Builtin.Parse(NCS("SOME_BUILT-IN")));
Assert.IsNotNull(Builtin.Parse(NCS("?-._A-Z")));
Assert.IsTrue(Builtin.IsValid("SOME_BUILT-IN"));
Assert.IsTrue(Builtin.IsValid("?-._A-Z"));
// bad examples
Throws(() => Builtin.Parse(NCS(""))); // cannot be empty
Throws(() => Builtin.Parse(NCS("4 cannot start with a number")));
Throws(() => Builtin.Parse(NCS("@ is not allowed")));
Throws(() => Builtin.Parse(NCS("# is not allowed")));
Throws(() => Builtin.Parse(NCS("# is not allowed")));
Throws(() => Builtin.Parse(NCS(" cannot start with space")));
Throws(() => Builtin.Parse(NCS("aNOPE"))); // cannot contain lowercase letters
}
/// <summary>
/// used by text
/// </summary>
/// <param name="value">value name</param>
/// <returns></returns>
public Value ResolveValue(string value, ObjectContext ctx)
{
var path = value.Split('.');
var obj = this;
var member = path.Last();
for (int i = 0; i < path.Length - 1; i++)
{
var fragment = path[i];
if (Builtin.IsBuiltInVariable(fragment))
{
obj = Builtin.GetBuiltInVariable(fragment, obj).ToObject();
}
else
{
throw new NotImplementedException();
}
}
return(obj.GetMember(member));
}
public virtual void Destroy(BuilderContext context)
{
if (context == null || context.Builtin == null)
{
return;
}
Builtin builtin = context.Builtin;
if (builtin.HasValue)
{
IDisposable value = builtin.Value as IDisposable;
if (value != null)
{
value.Dispose();
}
else
{
System.Collections.IEnumerable collection = builtin.Value as System.Collections.IEnumerable;
if (collection != null)
{
foreach (object item in collection)
{
IDisposable disposable = item as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
}
builtin.Value = null;
}
}
internal static object ImportLightThrow(CodeContext /*!*/ context, string fullName, PythonTuple from, int level)
{
PythonContext pc = context.LanguageContext;
if (level == -1)
{
// no specific level provided, call the 4 param version so legacy code continues to work
var site = pc.OldImportSite;
return(site.Target(
site,
context,
FindImportFunction(context),
fullName,
Builtin.globals(context),
context.Dict,
from
));
}
else
{
// relative import or absolute import, in other words:
//
// from . import xyz
// or
// from __future__ import absolute_import
var site = pc.ImportSite;
return(site.Target(
site,
context,
FindImportFunction(context),
fullName,
Builtin.globals(context),
context.Dict,
from,
level
));
}
}
public PluginServiceProvider(Builtin builtin) : base(builtin.Name)
{
var path = builtin.Properties.GetRawValue("path");
if (string.IsNullOrWhiteSpace(path))
{
if (string.Equals(builtin.FullPath, SERVICES_PATH, StringComparison.OrdinalIgnoreCase))
{
_path = builtin.FullPath;
}
else
{
_path = PluginPath.Combine(SERVICES_PATH, builtin.Name);
}
}
else
{
_path = path == "." ? builtin.FullPath : path;
}
_context = builtin.Context;
this.Storage = new PluginServiceStorage(this);
}
private bool TryGetMember(CodeContext codeContext, object obj, string name, out object value)
{
NamespaceTracker nt = obj as NamespaceTracker;
if (nt != null)
{
value = NamespaceTrackerOps.GetCustomMember(codeContext, nt, name);
return(value != OperationFailed.Value);
}
object result = Builtin.getattr(codeContext, obj, name, this);
if (result == this)
{
value = null;
return(false);
}
else
{
value = result;
return(true);
}
}
public PluginPredicationContext(string parameter, Builtin builtin, PluginTreeNode node, Plugin plugin)
{
_parameter = parameter;
_builtin = builtin;
if (builtin != null)
{
_node = builtin.Node;
_plugin = builtin.Plugin;
}
if (node != null)
{
_node = node;
_plugin = plugin ?? node.Plugin;
}
if (plugin != null)
{
_plugin = plugin;
}
}
private string ReplaceText(string format)
{
if (_depth == 2)
{
throw PythonOps.ValueError("Max string recursion exceeded");
}
StringBuilder builder = new StringBuilder();
foreach (PythonTuple pt in StringFormatParser.Parse(format))
{
string text = (string)pt[0];
string fieldName = (string)pt[1];
string formatSpec = (string)pt[2];
string conversionStr = (string)pt[3];
char? conversion = conversionStr != null && conversionStr.Length > 0 ? conversionStr[0] : (char?)null;
builder.Append(text);
if (fieldName != null)
{
// get the argument value
object argValue = GetArgumentValue(ParseFieldName(fieldName, true));
// apply the conversion
argValue = ApplyConversion(conversion, argValue);
// handle computed format specifiers
formatSpec = ReplaceComputedFormats(formatSpec);
// append the string
builder.Append(Builtin.format(_context.SharedContext, argValue, formatSpec));
}
}
return(builder.ToString());
}
IC_PyFile_WriteObject(IntPtr objPtr, IntPtr filePtr, int use_str)
{
try
{
object obj = this.Retrieve(objPtr);
string s;
if (use_str % 2 == 1)
{
s = (string)PythonCalls.Call(Builtin.str, new object[] { obj });
}
else
{
s = (string)Builtin.repr(this.scratchContext, obj);
}
PythonFile file = (PythonFile)this.Retrieve(filePtr);
file.write(s);
return(0);
}
catch (Exception e)
{
this.LastException = e;
return(-1);
}
}
PySequence_Check(IntPtr objPtr)
{
object obj = this.Retrieve(objPtr);
if (Builtin.isinstance(obj, Builtin.xrange))
{
return(1);
}
// I don't *think* a type's attributes can meaningfully count...
// TODO: regardless, there must be a better way to do this
if ((!Builtin.isinstance(obj, TypeCache.PythonType)) &&
Builtin.hasattr(this.scratchContext, obj, "__len__") &&
Builtin.hasattr(this.scratchContext, obj, "__getitem__") &&
Builtin.hasattr(this.scratchContext, obj, "__add__") &&
Builtin.hasattr(this.scratchContext, obj, "__radd__") &&
Builtin.hasattr(this.scratchContext, obj, "__mul__") &&
Builtin.hasattr(this.scratchContext, obj, "__rmul__") &&
!Builtin.hasattr(this.scratchContext, obj, "__coerce__"))
{
return(1);
}
return(0);
}
protected RouteValueDictionary ResolveValues(string text, Builtin builtin)
{
RouteValueDictionary result = new RouteValueDictionary();
if(string.IsNullOrWhiteSpace(text))
return result;
var parts = text.Split(',');
foreach(string part in parts)
{
int index = part.IndexOf('=');
if(index > 0)
{
string key = part.Substring(0, index).Trim();
if(!string.IsNullOrEmpty(key))
{
string valueText = part.Substring(index + 1);
if(string.IsNullOrWhiteSpace(valueText))
result.Add(key, System.Web.Mvc.UrlParameter.Optional);
else
result.Add(key, valueText);
}
}
}
return result;
}
/// <summary>
/// Set a builtin flash variable
/// </summary>
/// <param name="name"></param>
/// <param name="val"></param>
public virtual void SetBuiltInVariable(string name, Value val)
{
Builtin.SetBuiltInVariable(name, this, val);
}
