public JToken Serialize(object value, Metadata.TypeInfo typeInfo)
{
if (value == null)
{
return(JValue.CreateNull());
}
// Arrays
if (typeInfo.IsArray)
{
return(SerializeArray(value, typeInfo));
}
// Enums
if (metadata.Enums.TryGetValue(typeInfo.Name, out Metadata.Enum enumMeta))
{
return(SerializeEnum(value));
}
// Primitive types
if (Enum.TryParse(typeInfo.Name, out Metadata.PrimitiveType result))
{
return(result == Metadata.PrimitiveType.Void ? JValue.CreateNull() : new JValue(value));
}
// Entity
if (metadata.Entities.TryGetValue(typeInfo.Name, out Metadata.Entity entity))
{
return(SerializeEntity(value, entity, typeInfo));
}
throw new SerializationException("Unknown type: " + typeInfo.Name);
}
//
public PropertyImpl(SpecifyParametersForm owner, string name, Metadata.TypeInfo type, IList <Attribute> attributes, string category, object value)
: base(owner, name, false, type, type, new Metadata.Parameter[0], false)
{
this.attributes = attributes;
this.category = category;
this.value = value;
}
/// <summary>
/// Deserializes a <c>jsonValue</c>
/// </summary>
/// <param name="jsonValue"></param>
/// <param name="typeInfo"></param>
/// <returns></returns>
public object Deserialize(JToken jsonValue, Metadata.TypeInfo typeInfo)
{
if (jsonValue is JValue val && val.Value == null)
{
return(null);
}
// Arrays
if (typeInfo.IsArray)
{
return(DeserializeArray(jsonValue, typeInfo));
}
// Enums
if (metadata.Enums.TryGetValue(typeInfo.Name, out Metadata.Enum enumMeta))
{
return(DeserializeEnum(jsonValue, enumMeta));
}
// Primitive types
if (Enum.TryParse(typeInfo.Name, out Metadata.PrimitiveType result))
{
return(jsonValue.ToObject(typeInfo.Type));
}
// Entity
if (metadata.Entities.TryGetValue(typeInfo.Name, out Metadata.Entity entity))
{
return(DeserializeObject(jsonValue as JObject, entity));
}
throw new SerializationException("Unknown type: " + typeInfo.Name);
}
//
public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, Component_Property creator, string category, bool referenceSupport)
: base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly)
{
this.creator = creator;
this.category = category;
this.referenceSupport = referenceSupport;
}
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Sphere sphere)
{
this.CastType = castType;
this.SelectedTypeOnly = selectedTypeOnly;
this.VisibleOnly = visibleOnly;
this.Sphere = sphere;
}
//
public EditorAction_NewResource(Metadata.TypeInfo type)
{
this.type = type;
ImageSmall = Properties.Resources.New_16;
ImageBig = Properties.Resources.New_32;
QatSupport = true;
GetState += delegate(EditorAction.GetStateContext context)
{
context.Enabled = true;
};
Click += delegate(EditorAction.ClickContext context)
{
var initData = new NewObjectWindow.CreationDataClass();
var window = EditorAPI.FindWindow <ResourcesWindow>();
string directory = window.ContentBrowser1.GetDirectoryPathOfSelectedFileOrParentDirectoryItem();
if (!string.IsNullOrEmpty(directory))
{
initData.initFileCreationDirectory = VirtualPathUtility.GetVirtualPathByReal(directory);
}
initData.initLockType = type;
EditorAPI.OpenNewObjectWindow(initData);
};
}
void TryNewObject(Metadata.TypeInfo lockType)
{
if (!CanNewObject(out List <Component> parentsForNewObjects))
{
return;
}
var data = new NewObjectWindow.CreationDataClass();
data.initDocumentWindow = this;
data.initParentObjects = new List <object>();
data.initParentObjects.AddRange(parentsForNewObjects);
//!!!!
//уникальное имя
data.initLockType = lockType;
data.initSupportAutoCreateAndClose = lockType != null;
//!!!!бывает что создавать другой объект? например для меша создавать mesh in space. где еще так
//!!!!выделить после создания
EditorAPI.OpenNewObjectWindow(data);
}
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Frustum frustum)
{
this.CastType = castType;
this.SelectedTypeOnly = selectedTypeOnly;
this.VisibleOnly = visibleOnly;
this.Frustum = frustum;
}
void Update()
{
if (needUpdate)
{
//!!!!slowly?
var demandedReturnType = GetDemandedReturnType();
if (demandedReturnType != createdPropertyReturnType || property == null)
{
Clear();
if (Enabled) //!!!!?
{
needUpdate = false;
if (demandedReturnType != null)
{
//!!!!TypeInfo?
Type unrefNetType = ReferenceUtility.GetUnreferencedType(demandedReturnType.GetNetType());
var type = MetadataManager.GetTypeOfNetType(unrefNetType);
//!!!!
var typeUnreferenced = type;
var p = new PropertyImpl(this, "Output", false, type, typeUnreferenced, new Metadata.Parameter[0], true, "Parameter", false);
p.Description = "";
property = p;
createdPropertyReturnType = demandedReturnType;
}
}
}
}
}
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Plane[] planes)
{
this.CastType = castType;
this.SelectedTypeOnly = selectedTypeOnly;
this.VisibleOnly = visibleOnly;
this.Planes = planes;
}
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Ray ray)
{
this.CastType = castType;
this.SelectedTypeOnly = selectedTypeOnly;
this.VisibleOnly = visibleOnly;
this.Ray = ray;
}
////////////
public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, Component_ConvertTo creator, string category, string displayName)
: base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly)
{
this.creator = creator;
this.category = category;
this.displayName = displayName;
}
public GetObjectsItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Bounds bounds)
{
this.CastType = castType;
this.SelectedTypeOnly = selectedTypeOnly;
this.VisibleOnly = visibleOnly;
this.Bounds = bounds;
}
public GetObjectsInSpaceItem(CastTypeEnum castType, Metadata.TypeInfo selectedTypeOnly, bool visibleOnly, Box box)
{
this.CastType = castType;
this.SelectedTypeOnly = selectedTypeOnly;
this.VisibleOnly = visibleOnly;
this.Box = box;
}
public Tab(string name, string type, Metadata.TypeInfo visibleOnlyForType = null, VisibleConditionDelegate visibleCondition = null)
{
Name = name;
Type = type;
VisibleOnlyForType = visibleOnlyForType;
VisibleCondition = visibleCondition;
}
//!!!!везде метод применить там где "CreateComponent("?
//!!!!расширять метод
public static int GetNewObjectInsertIndex(Component parent, Metadata.TypeInfo objectType)
{
//Rendering effects
if (MetadataManager.GetTypeOfNetType(typeof(Component_RenderingEffect)).IsAssignableFrom(objectType))
{
if (GetRenderingEffectDefaultOrderOfEffect(objectType, out var value))
{
int index = 0;
foreach (var child in parent.Components)
{
if (MetadataManager.GetTypeOfNetType(typeof(Component_RenderingEffect)).IsAssignableFrom(child.BaseType))
{
if (GetRenderingEffectDefaultOrderOfEffect(child.BaseType, out var childValue))
{
if (value < childValue)
{
return(index);
}
}
}
index++;
}
}
}
return(-1);
}
//
public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, string category, string displayName, bool referenceSupport, Metadata.Parameter parameter, bool invoke)
: base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly)
{
this.category = category;
this.displayName = displayName;
this.referenceSupport = referenceSupport;
this.parameter = parameter;
this.invoke = invoke;
}
////////////
public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, Component_MethodBody creator, string category, string displayName, ParameterType parameterType, int invokeParameterIndex)
: base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly)
{
this.creator = creator;
this.category = category;
this.displayName = displayName;
this.parameterType = parameterType;
this.invokeParameterIndex = invokeParameterIndex;
}
public static void Add(Metadata.TypeInfo type)
{
var typeName = type.Name;
if (!string.IsNullOrEmpty(Favorites))
{
Favorites += "|";
}
Favorites += typeName;
}
//!!!!new
public static Metadata.TypeInfo GetUnreferencedType(Metadata.TypeInfo type)
{
var netType = type.GetNetType();
if (IsReferenceType(netType))
{
return(MetadataManager.GetTypeOfNetType(GetUnderlyingType(netType)));
}
return(type);
}
EventImpl CreateEvent()
{
Metadata.TypeInfo eventHandlerType = null;
//EventHandlerType property
var eventHandlerTypeProperty = EventHandlerType;
if (eventHandlerTypeProperty.ReferenceSpecified)
{
eventHandlerType = eventHandlerTypeProperty;
}
else
{
//!!!!
//var parameters = new List<Component_MemberParameter>();
//foreach( var p in GetComponents<Component_MemberParameter>( false, false ) )
//{
// if( p.Enabled )
// parameters.Add( p );
//}
//var parameters2 = new List<Metadata.Parameter>();
//foreach( var p in parameters )
//{
// Metadata.Parameter p2 = p.CreateMetadataParameter();
// if( p2 == null )
// {
// //!!!!
// return null;
// }
// parameters2.Add( p2 );
//}
////!!!!?
//var args = new List<Type>();
//foreach( var param in netMethod.GetParameters() )
// args.Add( param.ParameterType );
//args.Add( netMethod.ReturnType );
//var delDecltype = Expression.GetDelegateType( args.ToArray() );
}
if (eventHandlerType != null)
{
var _event = new EventImpl(Parent, Name, Static, eventHandlerType, this);
_event.Description = Description;
return(_event);
}
else
{
return(null);
}
}
public static bool CheckTypeSupportedByPlayer(Metadata.TypeInfo type)
{
foreach (var t in supportedTypesByPlayer)
{
if (t.IsAssignableFrom(type))
{
return(true);
}
}
return(false);
}
private JToken SerializeArray(object value, Metadata.TypeInfo typeInfo)
{
var array = value as IEnumerable;
var tokens = new List <JToken>();
foreach (object arrValue in array)
{
JToken token = Serialize(arrValue, typeInfo.GetElementInfo());
tokens.Add(token);
}
return(new JArray(tokens.ToArray()));
}
static bool GetRenderingEffectDefaultOrderOfEffect(Metadata.TypeInfo type, out double value)
{
var attribs = type.GetCustomAttributes(typeof(Component_RenderingEffect.DefaultOrderOfEffectAttribute), true);
if (attribs.Length != 0)
{
value = ((Component_RenderingEffect.DefaultOrderOfEffectAttribute)attribs[0]).Value;
return(true);
}
value = -1;
return(false);
}
public static bool Contains(Metadata.TypeInfo type)
{
var typeNames = Favorites.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var typeName2 in typeNames)
{
if (typeName2 == type.Name)
{
return(true);
}
}
return(false);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static Component CreateComponent(Metadata.TypeInfo type, object[] constructorParams, bool createHierarchyController,
bool componentEnable)
{
var component = (Component)type.InvokeInstance(constructorParams);
component.Enabled = componentEnable;
if (createHierarchyController)
{
CreateHierarchyControllerForRootComponent(component, null, true); //, true );
}
return(component);
}
string GetExtension(Metadata.TypeInfo type)
{
//!!!!а как для своих типов расширения добавлять. нужно атрибуты уметь типу добавлять. тогда еще и свои типы атрибутов может быть
var ar = type.GetNetType().GetCustomAttributes(typeof(ResourceFileExtensionAttribute), true);
if (ar.Length != 0)
{
var attr = (ResourceFileExtensionAttribute)ar[0];
return(attr.Extension);
}
//!!!!!
return("UNKNOWN");
}
private object DeserializeArray(JToken jsonValue, Metadata.TypeInfo typeInfo)
{
var jsonArr = jsonValue as JArray;
if (jsonArr == null)
{
throw new SerializationException("Array type expected");
}
var array = Array.CreateInstance(typeInfo.Type, jsonArr.Count);
for (int n = 0; n < jsonArr.Count; n++)
{
array.SetValue(Deserialize(jsonArr[n], typeInfo.GetElementInfo()), n);
}
return(array);
}
void UpdateSelectedType()
{
Metadata.TypeInfo newType = null;
bool newTypeCanSelect = false;
ContentBrowser.Item item = null;
if (contentBrowser1.SelectedItems.Length != 0)
{
item = contentBrowser1.SelectedItems[0];
}
if (item != null)
{
item.CalculateReferenceValue(null, MetadataManager.GetTypeOfNetType(typeof(Metadata.TypeInfo)),
out string referenceValue, out bool canSet);
if (canSet)
{
if (!string.IsNullOrEmpty(referenceValue))
{
newType = (Metadata.TypeInfo)MetadataManager.GetValueByReference(
contentBrowser1.SetReferenceModeData.demandedType.GetNetType(), null, referenceValue);
newTypeCanSelect = true;
}
else
{
newTypeCanSelect = true;
}
}
//check can be selected
if (newType != null && !creationData.initDemandedType.IsAssignableFrom(newType))
{
newType = null;
newTypeCanSelect = false;
}
}
//change
if (selectedType != newType || selectedTypeCanSelect != newTypeCanSelect)
{
selectedType = newType;
selectedTypeCanSelect = newTypeCanSelect;
SelectedTypeChanged();
}
}
public static void Remove(Metadata.TypeInfo type)
{
var typeNames = Favorites.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
Favorites = "";
foreach (var typeName2 in typeNames)
{
if (typeName2 != type.Name)
{
if (!string.IsNullOrEmpty(Favorites))
{
Favorites += "|";
}
Favorites += typeName2;
}
}
}
