private void ClearInternalData()
{
Properties = null;
Links = null;
Modifications = null;
ParentPrefabGUID = null;
PrefabGUID = "STRIPPED";
}
public PrefabInternalData(PEPrefabScript script)
{
this.Properties = script.Properties;
this.Links = script.Links;
this.Modifications = script.Modifications;
this.ParentPrefabGUID = script.ParentPrefabGUID;
this.PrefabGUID = script.PrefabGUID;
}
static private void AddModification(this PEModifications _this, PEModifications.PropertyData data)
{
foreach (var mod in _this.Modificated)
{
if (mod.PropertyPath == data.PropertyPath && mod.Object == data.Object && mod.ObjeckLink == data.ObjeckLink)
{
return;
}
}
_this.Modificated.Add(data);
}
static internal void CalculateModifications(this PEModifications _this, PEPrefabScript prefab, PEPrefabScript instance)
{
instance.Modifications.Modificated.RemoveAll(m => m.Mode == PEModifications.PropertyData.PropertyMode.Default);
var counter = 0;
foreach (var link in instance.Links.Links)
{
if (link == null || link.InstanceTarget == null || link.InstanceTarget == instance || link.InstanceTarget is PEPrefabScript)
{
continue;
}
var so = new SerializedObject(link.InstanceTarget);
var property = so.GetIterator();
var prefabObjectLink = prefab.Links[link];
if (prefabObjectLink == null)
{
continue;
}
var prefabObject = prefabObjectLink.InstanceTarget;
if (prefabObject == null)
{
continue;
}
var prefabSerializedObject = new SerializedObject(prefabObject);
while (property.Next(CheckChild(property)))
{
counter++;
if (PEUtils.PropertyFilter(property))
{
continue;
}
var prefabProperty = prefabSerializedObject.FindProperty(property.propertyPath);
var isArray = property.propertyPath.Contains(".Array.data[");
var isInherited = link.InstanceTarget.GetType().IsSubclassOf(prefabObject.GetType());
if (prefabProperty == null && !isArray && !isInherited)
{
if (PEPrefs.DebugLevel > 0)
{
Debug.Log("Property not found(Some times its happens) " + property.propertyPath);
}
continue;
}
var instanceValue = property.GetPropertyValue();
var prefabValue = prefabProperty == null ? null : prefabProperty.GetPropertyValue();
var isChanged = !object.Equals(instanceValue, prefabValue);
if (isChanged)
{
if (property.propertyType == SerializedPropertyType.ObjectReference)
{
var instanceLink = instance.Links[instanceValue as Object];
var prefabLink = prefab.Links[prefabValue as Object];
if (prefabLink != null && instanceLink != null)
{
isChanged = prefabLink.LIIF != instanceLink.LIIF;
}
}
else
{
var animationCurve = instanceValue as AnimationCurve;
if (animationCurve != null)
{
isChanged = !PEUtils.Compare(animationCurve, prefabValue as AnimationCurve);
}
}
}
if (!isChanged)
{
continue;
}
instance.Modifications.AddModification(new PEModifications.PropertyData {
Object = link.InstanceTarget,
PropertyPath = property.propertyPath,
ObjeckLink = link.LIIF,
});
}
}
instance.Modifications.CalculateStructureDiff(prefab, instance);
}
static private void CalculateStructureDiff(this PEModifications _this, PEPrefabScript prefab, PEPrefabScript instance)
{
_this.NonPrefabObjects.Clear();
var hierarchy = EditorUtility.CollectDeepHierarchy(new[] { instance });
foreach (var transform in hierarchy.OfType <Transform>())
{
if (transform.parent == null)
{
continue;
}
var link = prefab.Links[instance.Links[transform]];
if (link != null)
{
continue;
}
_this.NonPrefabObjects.Add(new PEModifications.HierarchyData {
child = transform,
parent = transform.parent
});
}
_this.NonPrefabComponents.Clear();
foreach (var component in hierarchy.Where(obj => !(obj is Transform)).OfType <Component>())
{
var link = prefab.Links[instance.Links[component]];
if (link != null || prefab.Links[instance.Links[component.gameObject.transform]] == null)
{
continue;
}
_this.NonPrefabComponents.Add(new PEModifications.ComponentsData {
child = component,
parent = component.gameObject
});
}
_this.RemovedObjects.Clear();
foreach (var link in prefab.Links.Links)
{
if (link.InstanceTarget is Transform)
{
continue;
}
if (instance.Links[link] == null || instance.Links[link].InstanceTarget == null)
{
_this.RemovedObjects.Add(link.LIIF);
}
}
_this.TransformParentChanges.Clear();
foreach (var link in instance.Links.Links)
{
var transform = link.InstanceTarget as Transform;
if (transform == null)
{
continue;
}
var currentTransform = transform;
if (currentTransform == instance.transform)
{
continue;
}
var currentTransformParent = currentTransform.parent;
if (prefab.Links[link] == null)
{
continue;
}
var otherTransform = prefab.Links[link].InstanceTarget as Transform;
var otherTransformParent = otherTransform.parent;
if (prefab.Links[otherTransformParent] == null || instance.Links[currentTransformParent] == null ||
prefab.Links[otherTransformParent].LIIF
!= instance.Links[currentTransformParent].LIIF)
{
_this.TransformParentChanges.Add(new PEModifications.HierarchyData {
child = currentTransform,
parent = currentTransformParent
});
}
}
}
private static void AddModification(this PEModifications _this, PEModifications.PropertyData data)
{
foreach (var mod in _this.Modificated)
if (mod.PropertyPath == data.PropertyPath && mod.Object == data.Object && mod.ObjeckLink == data.ObjeckLink)
return;
_this.Modificated.Add(data);
}
