private void Awake()
{
m_editor = IOC.Resolve <IRTE>();
m_layersInfo = (LayersInfo)m_editor.Selection.activeObject;
foreach (LayersInfo.Layer layer in m_layersInfo.Layers)
{
GameObject editor = Instantiate(m_editorPrefab, m_editorsPanel, false);
TextMeshProUGUI text = editor.GetComponentInChildren <TextMeshProUGUI>(true);
if (text != null)
{
text.text = layer.Index + ": ";
}
StringEditor stringEditor = editor.GetComponentInChildren <StringEditor>(true);
if (stringEditor != null)
{
if (layer.Index <= 5)
{
TMP_InputField inputField = stringEditor.GetComponentInChildren <TMP_InputField>(true);
inputField.selectionColor = new Color(0, 0, 0, 0);
inputField.readOnly = true;
}
stringEditor.Init(layer, layer, Strong.MemberInfo((LayersInfo.Layer x) => x.Name), null, string.Empty, null, () => m_isDirty = true, null, false);
}
}
}
private void Awake()
{
m_terrainEditor = GetComponentInParent <TerrainEditor>();
m_editor = IOC.Resolve <IRTE>();
m_editor.Selection.SelectionChanged += OnEditorSelectionChanged;
m_terrainCutoutRenderer = IOC.Resolve <ITerrainCutoutMaskRenderer>();
m_terrainCutoutRenderer.ObjectImageLayer = m_editor.CameraLayerSettings.ResourcePreviewLayer;
m_source = FindObjectOfType <TerrainBrushSource>();
if (m_source == null)
{
m_source = new GameObject("TerrainBrushSource").AddComponent <TerrainBrushSource>();
}
if (m_brushesList != null)
{
m_brushesList.SelectionChanged += OnBrushesSelectionChanged;
m_brushesList.ItemDataBinding += OnBrushesDataBinding;
m_brushesList.CanDrag = false;
m_brushesList.CanEdit = false;
m_brushesList.CanRemove = false;
m_brushesList.CanReorder = false;
m_brushesList.CanReparent = false;
m_brushesList.CanSelectAll = false;
m_brushesList.CanUnselectAll = false;
}
if (m_brushSizeEditor != null)
{
BrushSize = 2.5f;
m_brushSizeEditor.Min = 0.5f;
m_brushSizeEditor.Max = 40;
m_brushSizeEditor.Init(this, this, Strong.MemberInfo((TerrainBrushEditor x) => x.BrushSize));
}
if (m_opacityEditor != null)
{
BrushOpacity = 100;
m_opacityEditor.Min = 0;
m_opacityEditor.Max = 100;
m_opacityEditor.Init(this, this, Strong.MemberInfo((TerrainBrushEditor x) => x.BrushOpacity));
}
if (m_createButton != null)
{
m_createButton.onClick.AddListener(OnCreateButtonClick);
}
if (m_addButton != null)
{
m_addButton.onClick.AddListener(OnAddButtonClick);
}
if (m_deleteButton != null)
{
m_deleteButton.onClick.AddListener(OnDeleteButtonClick);
}
}
protected override void InitEditor(PropertyEditor editor, PropertyDescriptor descriptor)
{
base.InitEditor(editor, descriptor);
if (RuntimeTools.LockAxes == null)
{
return;
}
if (descriptor.ComponentMemberInfo == Strong.MemberInfo((Transform x) => x.position))
{
Vector3Editor vector3Editor = (Vector3Editor)editor;
vector3Editor.IsXInteractable = !RuntimeTools.LockAxes.PositionX;
vector3Editor.IsYInteractable = !RuntimeTools.LockAxes.PositionY;
vector3Editor.IsZInteractable = !RuntimeTools.LockAxes.PositionZ;
}
if (descriptor.ComponentMemberInfo == Strong.MemberInfo((Transform x) => x.rotation))
{
Vector3Editor vector3Editor = (Vector3Editor)editor;
vector3Editor.IsXInteractable = !RuntimeTools.LockAxes.RotationX;
vector3Editor.IsYInteractable = !RuntimeTools.LockAxes.RotationY;
vector3Editor.IsZInteractable = !RuntimeTools.LockAxes.RotationZ;
}
if (descriptor.ComponentMemberInfo == Strong.MemberInfo((Transform x) => x.localScale))
{
Vector3Editor vector3Editor = (Vector3Editor)editor;
vector3Editor.IsXInteractable = !RuntimeTools.LockAxes.ScaleX;
vector3Editor.IsYInteractable = !RuntimeTools.LockAxes.ScaleY;
vector3Editor.IsZInteractable = !RuntimeTools.LockAxes.ScaleZ;
}
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo groupInfo = Strong.MemberInfo((SelectDisplayFieldsBehaviour x) => x.Group);
MemberInfo field1Info = Strong.MemberInfo((SelectDisplayFieldsBehaviour x) => x.Field1);
MemberInfo field2Info = Strong.MemberInfo((SelectDisplayFieldsBehaviour x) => x.Field2);
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor("Group", editor.Component, groupInfo)
{
ValueChangedCallback = () => editor.BuildEditor()
});
SelectDisplayFieldsBehaviour behaviour = (SelectDisplayFieldsBehaviour)editor.Component;
switch (behaviour.Group)
{
case FieldGroup.Group1:
descriptors.Add(new PropertyDescriptor("Field1", editor.Component, field1Info));
break;
case FieldGroup.Group2:
descriptors.Add(new PropertyDescriptor("Field2", editor.Component, field2Info));
break;
}
return(descriptors.ToArray());
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo groupInfo = Strong.MemberInfo((SelectDisplayFieldsBehaviour x) => x.Group);
MemberInfo field1Info = Strong.MemberInfo((SelectDisplayFieldsBehaviour x) => x.Field1);
MemberInfo field2Info = Strong.MemberInfo((SelectDisplayFieldsBehaviour x) => x.Field2);
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor("Group", editor.Components, groupInfo)
{
ValueChangedCallback = () => editor.BuildEditor()
});
IEnumerable <FieldGroup> groups = editor.Components.Where(component => component != null).OfType <SelectDisplayFieldsBehaviour>().Select(behavior => behavior.Group).Distinct();
foreach (FieldGroup group in groups)
{
switch (group)
{
case FieldGroup.Group1:
descriptors.Add(new PropertyDescriptor("Field1", editor.Components, field1Info));
break;
case FieldGroup.Group2:
descriptors.Add(new PropertyDescriptor("Field2", editor.Components, field2Info));
break;
}
}
return(descriptors.ToArray());
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo connectedBodyInfo = Strong.MemberInfo((SpringJoint x) => x.connectedBody);
MemberInfo anchorInfo = Strong.MemberInfo((SpringJoint x) => x.anchor);
MemberInfo autoConfigAnchorInfo = Strong.MemberInfo((SpringJoint x) => x.autoConfigureConnectedAnchor);
MemberInfo connectedAnchorInfo = Strong.MemberInfo((SpringJoint x) => x.connectedAnchor);
MemberInfo springInfo = Strong.MemberInfo((SpringJoint x) => x.spring);
MemberInfo damperInfo = Strong.MemberInfo((SpringJoint x) => x.damper);
MemberInfo minDistanceInfo = Strong.MemberInfo((SpringJoint x) => x.minDistance);
MemberInfo maxDistanceInfo = Strong.MemberInfo((SpringJoint x) => x.maxDistance);
MemberInfo toleranceInfo = Strong.MemberInfo((SpringJoint x) => x.tolerance);
MemberInfo breakForceInfo = Strong.MemberInfo((SpringJoint x) => x.breakForce);
MemberInfo breakTorqueInfo = Strong.MemberInfo((SpringJoint x) => x.breakTorque);
MemberInfo enableCollisionInfo = Strong.MemberInfo((SpringJoint x) => x.enableCollision);
MemberInfo enablePreporcessingInfo = Strong.MemberInfo((SpringJoint x) => x.enablePreprocessing);
return(new[]
{
new PropertyDescriptor("ConnectedBody", editor.Component, connectedBodyInfo),
new PropertyDescriptor("Anchor", editor.Component, anchorInfo),
new PropertyDescriptor("Auto Configure Connected Anchor", editor.Component, autoConfigAnchorInfo),
new PropertyDescriptor("Connected Anchor", editor.Component, connectedAnchorInfo),
new PropertyDescriptor("Spring", editor.Component, springInfo),
new PropertyDescriptor("Damper", editor.Component, damperInfo),
new PropertyDescriptor("MinDistance", editor.Component, minDistanceInfo),
new PropertyDescriptor("MaxDistance", editor.Component, maxDistanceInfo),
new PropertyDescriptor("Tolerance", editor.Component, toleranceInfo),
new PropertyDescriptor("Break Force", editor.Component, breakForceInfo),
new PropertyDescriptor("Break Torque", editor.Component, breakTorqueInfo),
new PropertyDescriptor("Enable Collision", editor.Component, enableCollisionInfo),
new PropertyDescriptor("Enable Preprocessing", editor.Component, enablePreporcessingInfo),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo convexInfo = Strong.MemberInfo((MeshCollider x) => x.convex);
MemberInfo isTriggerInfo = Strong.MemberInfo((MeshCollider x) => x.isTrigger);
MemberInfo materialInfo = Strong.MemberInfo((MeshCollider x) => x.sharedMaterial);
MemberInfo meshInfo = Strong.MemberInfo((MeshCollider x) => x.sharedMesh);
MeshCollider collider = (MeshCollider)editor.Component;
if (collider.convex)
{
return(new[]
{
new PropertyDescriptor("Convex", editor.Component, convexInfo, convexInfo, valueChanged),
new PropertyDescriptor("Is Trigger", editor.Component, isTriggerInfo, isTriggerInfo),
new PropertyDescriptor("Material", editor.Component, materialInfo, materialInfo),
new PropertyDescriptor("Mesh", editor.Component, meshInfo, meshInfo),
});
}
else
{
return(new[]
{
new PropertyDescriptor("Convex", editor.Component, convexInfo, convexInfo, valueChanged),
new PropertyDescriptor("Material", editor.Component, materialInfo, materialInfo),
new PropertyDescriptor("Mesh", editor.Component, meshInfo, meshInfo),
});
}
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo materialsInfo = Strong.MemberInfo((SkinnedMeshRenderer x) => x.sharedMaterials);
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor("Materials", editor.Component, materialsInfo, materialsInfo));
return(descriptors.ToArray());
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo sharedMeshInfo = Strong.MemberInfo((MeshFilter x) => x.sharedMesh);
return(new[]
{
new PropertyDescriptor("Mesh", editor.Component, sharedMeshInfo, sharedMeshInfo)
});
}
protected override void InitOverride(object target, MemberInfo memberInfo, string label = null)
{
base.InitOverride(target, memberInfo, label);
BoundsAccessor accessor = new BoundsAccessor(this);
m_center.Init(accessor, Strong.MemberInfo((BoundsAccessor x) => x.Center), "Center", OnValueChanging, null, OnEndEdit, false);
m_extents.Init(accessor, Strong.MemberInfo((BoundsAccessor x) => x.Extents), "Extents", OnValueChanging, null, OnEndEdit, false);
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo materials = Strong.MemberInfo((MeshRenderer x) => x.sharedMaterials);
return(new[]
{
new PropertyDescriptor("Materials", editor.Component, materials, materials),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo isTriggerInfo = Strong.MemberInfo((BoxCollider x) => x.isTrigger);
MemberInfo materialInfo = Strong.MemberInfo((BoxCollider x) => x.sharedMaterial);
MemberInfo centerInfo = Strong.MemberInfo((BoxCollider x) => x.center);
MemberInfo sizeInfo = Strong.MemberInfo((BoxCollider x) => x.size);
return(new[]
{
new PropertyDescriptor("Is Trigger", editor.Component, isTriggerInfo, isTriggerInfo),
new PropertyDescriptor("Material", editor.Component, materialInfo, materialInfo),
new PropertyDescriptor("Center", editor.Component, centerInfo, centerInfo),
new PropertyDescriptor("Size", editor.Component, sizeInfo, sizeInfo),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converterObj)
{
TransformPropertyConverter converter = (TransformPropertyConverter)converterObj;
MemberInfo position = Strong.MemberInfo((Transform x) => x.position);
MemberInfo rotation = Strong.MemberInfo((Transform x) => x.rotation);
MemberInfo rotationConverted = Strong.MemberInfo((TransformPropertyConverter x) => x.Rotation);
MemberInfo scale = Strong.MemberInfo((Transform x) => x.localScale);
return(new[]
{
new PropertyDescriptor("Position", editor.Component, position, position),
new PropertyDescriptor("Rotation", converter, rotationConverted, rotation),
new PropertyDescriptor("Scale", editor.Component, scale, scale)
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo isTriggerInfo = Strong.MemberInfo((SphereCollider x) => x.isTrigger);
MemberInfo materialInfo = Strong.MemberInfo((SphereCollider x) => x.sharedMaterial);
MemberInfo centerInfo = Strong.MemberInfo((SphereCollider x) => x.center);
MemberInfo radiusInfo = Strong.MemberInfo((SphereCollider x) => x.radius);
return(new[]
{
new PropertyDescriptor("Is Trigger", editor.Component, isTriggerInfo, isTriggerInfo),
new PropertyDescriptor("Material", editor.Component, materialInfo, materialInfo),
new PropertyDescriptor("Center", editor.Component, centerInfo, centerInfo),
new PropertyDescriptor("Radius", editor.Component, radiusInfo, radiusInfo),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo connectedBodyInfo = Strong.MemberInfo((HingeJoint x) => x.connectedBody);
MemberInfo anchorInfo = Strong.MemberInfo((HingeJoint x) => x.anchor);
MemberInfo axisInfo = Strong.MemberInfo((HingeJoint x) => x.axis);
MemberInfo autoConfigAnchorInfo = Strong.MemberInfo((HingeJoint x) => x.autoConfigureConnectedAnchor);
MemberInfo connectedAnchorInfo = Strong.MemberInfo((HingeJoint x) => x.connectedAnchor);
MemberInfo useSpringInfo = Strong.MemberInfo((HingeJoint x) => x.useSpring);
MemberInfo springInfo = Strong.MemberInfo((HingeJoint x) => x.spring);
MemberInfo useMotorInfo = Strong.MemberInfo((HingeJoint x) => x.useMotor);
MemberInfo motorInfo = Strong.MemberInfo((HingeJoint x) => x.motor);
MemberInfo useLimitsInfo = Strong.MemberInfo((HingeJoint x) => x.useLimits);
MemberInfo limitsInfo = Strong.MemberInfo((HingeJoint x) => x.limits);
MemberInfo breakForceInfo = Strong.MemberInfo((HingeJoint x) => x.breakForce);
MemberInfo breakTorqueInfo = Strong.MemberInfo((HingeJoint x) => x.breakTorque);
MemberInfo enableCollisionInfo = Strong.MemberInfo((HingeJoint x) => x.enableCollision);
MemberInfo enablePreporcessingInfo = Strong.MemberInfo((HingeJoint x) => x.enablePreprocessing);
return(new[]
{
new PropertyDescriptor("ConnectedBody", editor.Component, connectedBodyInfo),
new PropertyDescriptor("Anchor", editor.Component, anchorInfo),
new PropertyDescriptor("Axis", editor.Component, axisInfo),
new PropertyDescriptor("Auto Configure Connected Anchor", editor.Component, autoConfigAnchorInfo),
new PropertyDescriptor("Connected Anchor", editor.Component, connectedAnchorInfo),
new PropertyDescriptor("Use Spring", editor.Component, useSpringInfo),
new PropertyDescriptor("Spring", editor.Component, springInfo),
new PropertyDescriptor("Use Motor", editor.Component, useMotorInfo),
new PropertyDescriptor("Motor", editor.Component, motorInfo),
new PropertyDescriptor("Use Limits", editor.Component, useLimitsInfo),
new PropertyDescriptor("Limits", editor.Component, limitsInfo)
{
ChildDesciptors = new[]
{
new PropertyDescriptor("Min", null, Strong.MemberInfo((JointLimits x) => x.min)),
new PropertyDescriptor("Max", null, Strong.MemberInfo((JointLimits x) => x.max)),
new PropertyDescriptor("Bounciness", null, Strong.MemberInfo((JointLimits x) => x.bounciness)),
new PropertyDescriptor("Bounce Min Velocity", null, Strong.MemberInfo((JointLimits x) => x.bounceMinVelocity)),
new PropertyDescriptor("Contact Distance", null, Strong.MemberInfo((JointLimits x) => x.contactDistance)),
}
},
new PropertyDescriptor("Break Force", editor.Component, breakForceInfo),
new PropertyDescriptor("Break Torque", editor.Component, breakTorqueInfo),
new PropertyDescriptor("Enable Collision", editor.Component, enableCollisionInfo),
new PropertyDescriptor("Enable Preprocessing", editor.Component, enablePreporcessingInfo),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo connectedBodyInfo = Strong.MemberInfo((SpringJoint x) => x.connectedBody);
MemberInfo breakForceInfo = Strong.MemberInfo((SpringJoint x) => x.breakForce);
MemberInfo breakTorqueInfo = Strong.MemberInfo((SpringJoint x) => x.breakTorque);
MemberInfo enableCollisionInfo = Strong.MemberInfo((SpringJoint x) => x.enableCollision);
MemberInfo enablePreporcessingInfo = Strong.MemberInfo((SpringJoint x) => x.enablePreprocessing);
return(new[]
{
new PropertyDescriptor("ConnectedBody", editor.Component, connectedBodyInfo),
new PropertyDescriptor("Break Force", editor.Component, breakForceInfo),
new PropertyDescriptor("Break Torque", editor.Component, breakTorqueInfo),
new PropertyDescriptor("Enable Collision", editor.Component, enableCollisionInfo),
new PropertyDescriptor("Enable Preprocessing", editor.Component, enablePreporcessingInfo),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
MemberInfo massInfo = Strong.MemberInfo((Rigidbody x) => x.mass);
MemberInfo dragInfo = Strong.MemberInfo((Rigidbody x) => x.drag);
MemberInfo angularDragInfo = Strong.MemberInfo((Rigidbody x) => x.angularDrag);
MemberInfo useGravityInfo = Strong.MemberInfo((Rigidbody x) => x.useGravity);
MemberInfo isKinematicInfo = Strong.MemberInfo((Rigidbody x) => x.isKinematic);
MemberInfo interpolationInfo = Strong.MemberInfo((Rigidbody x) => x.interpolation);
MemberInfo collisionDetectionInfo = Strong.MemberInfo((Rigidbody x) => x.collisionDetectionMode);
return(new[]
{
new PropertyDescriptor("Mass", editor.Component, massInfo, massInfo),
new PropertyDescriptor("Drag", editor.Component, dragInfo, dragInfo),
new PropertyDescriptor("Angular Drag", editor.Component, angularDragInfo, angularDragInfo),
new PropertyDescriptor("Use Gravity", editor.Component, useGravityInfo, useGravityInfo),
new PropertyDescriptor("Is Kinematic", editor.Component, isKinematicInfo, isKinematicInfo),
new PropertyDescriptor("Interpolation", editor.Component, interpolationInfo, interpolationInfo),
new PropertyDescriptor("Collision Detection", editor.Component, collisionDetectionInfo, collisionDetectionInfo),
});
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converterObj)
{
CapsuleColliderPropertyConverter converter = (CapsuleColliderPropertyConverter)converterObj;
MemberInfo isTriggerInfo = Strong.MemberInfo((CapsuleCollider x) => x.isTrigger);
MemberInfo materialInfo = Strong.MemberInfo((CapsuleCollider x) => x.sharedMaterial);
MemberInfo centerInfo = Strong.MemberInfo((CapsuleCollider x) => x.center);
MemberInfo radiusInfo = Strong.MemberInfo((CapsuleCollider x) => x.radius);
MemberInfo heightInfo = Strong.MemberInfo((CapsuleCollider x) => x.height);
MemberInfo directionInfo = Strong.MemberInfo((CapsuleCollider x) => x.direction);
MemberInfo directionConvertedInfo = Strong.MemberInfo((CapsuleColliderPropertyConverter x) => x.Direction);
return(new[]
{
new PropertyDescriptor("Is Trigger", editor.Component, isTriggerInfo, isTriggerInfo),
new PropertyDescriptor("Material", editor.Component, materialInfo, materialInfo),
new PropertyDescriptor("Center", editor.Component, centerInfo, centerInfo),
new PropertyDescriptor("Radius", editor.Component, radiusInfo, radiusInfo),
new PropertyDescriptor("Height", editor.Component, heightInfo, heightInfo),
new PropertyDescriptor("Direction", converter, directionConvertedInfo, directionInfo),
});
}
protected virtual void Start()
{
m_parentDialog = GetComponentInParent <Dialog>();
if (m_parentDialog != null)
{
m_parentDialog.IsOkVisible = true;
}
HashSet <string> alreadyAddedHs = new HashSet <string>();
RuntimeAnimationProperty[] alreadyAddedProperties = View.Props;
for (int i = 0; i < alreadyAddedProperties.Length; ++i)
{
RuntimeAnimationProperty property = alreadyAddedProperties[i];
alreadyAddedHs.Add(property.ComponentTypeName + " " + property.PropertyName);
}
MemberInfo enabledProperty = Strong.MemberInfo((Behaviour x) => x.enabled);
List <RuntimeAnimationProperty> components = new List <RuntimeAnimationProperty>();
IEditorsMap editorsMap = IOC.Resolve <IEditorsMap>();
Type[] editableTypes = editorsMap.GetEditableTypes();
for (int i = 0; i < editableTypes.Length; ++i)
{
Type editableType = editableTypes[i];
if (!(typeof(Component).IsAssignableFrom(editableType)) || typeof(Component) == editableType)
{
continue;
}
Component targetComponent = Target.GetComponent(editableType);
if (targetComponent == null)
{
continue;
}
m_voidComponentEditor.Components = new[] { targetComponent };
RuntimeAnimationProperty component = new RuntimeAnimationProperty();
component.ComponentDisplayName = editableType.Name;
component.ComponentTypeName = string.Format("{0},{1}", editableType.FullName, editableType.Assembly.FullName.Split(',')[0]);
component.Children = new List <RuntimeAnimationProperty>();
component.Component = m_voidComponentEditor.Components[0];
PropertyDescriptor[] propertyDescriptors = editorsMap.GetPropertyDescriptors(editableType, m_voidComponentEditor);
for (int j = 0; j < propertyDescriptors.Length; ++j)
{
PropertyDescriptor propertyDescriptor = propertyDescriptors[j];
Type memberType = propertyDescriptor.MemberType;
if (memberType.IsClass || memberType.IsEnum || typeof(MonoBehaviour).IsAssignableFrom(editableType) && propertyDescriptor.MemberInfo is PropertyInfo)
{
continue;
}
if (alreadyAddedHs.Contains(component.ComponentTypeName + " " + propertyDescriptor.MemberInfo.Name))
{
continue;
}
RuntimeAnimationProperty property = new RuntimeAnimationProperty();
property.Parent = component;
property.ComponentTypeName = component.ComponentTypeName;
property.ComponentDisplayName = component.ComponentDisplayName;
property.PropertyName = propertyDescriptor.MemberInfo.Name;
property.PropertyDisplayName = propertyDescriptor.Label;
if (propertyDescriptor.MemberInfo.Name == enabledProperty.Name && propertyDescriptor.MemberInfo.DeclaringType == enabledProperty.DeclaringType)
{
property.AnimationPropertyName = "m_Enabled";
}
else
{
if (string.IsNullOrEmpty(propertyDescriptor.AnimationPropertyName))
{
Type componentType = property.ComponentType;
if (typeof(Component).IsAssignableFrom(componentType) && !typeof(MonoBehaviour).IsAssignableFrom(componentType))
{
//Trying to derive serialized property name
string aPropName = propertyDescriptor.MemberInfo.Name;
property.AnimationPropertyName = "m_" + Char.ToUpper(aPropName[0]) + aPropName.Substring(1);
}
else
{
property.AnimationPropertyName = propertyDescriptor.MemberInfo.Name;
}
}
else
{
property.AnimationPropertyName = propertyDescriptor.AnimationPropertyName;
}
}
property.Component = propertyDescriptor.Target;
component.Children.Add(property);
}
if (component.Children.Count > 0)
{
components.Add(component);
}
m_voidComponentEditor.Components = null;
}
m_propertiesTreeView.Items = components;
}
public PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
Light light = (Light)editor.Component;
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo enabledInfo = Strong.MemberInfo((Light x) => x.enabled);
MemberInfo lightTypeInfo = Strong.MemberInfo((Light x) => x.type);
MemberInfo colorInfo = Strong.MemberInfo((Light x) => x.color);
MemberInfo intensityInfo = Strong.MemberInfo((Light x) => x.intensity);
MemberInfo bounceIntensityInfo = Strong.MemberInfo((Light x) => x.bounceIntensity);
MemberInfo shadowTypeInfo = Strong.MemberInfo((Light x) => x.shadows);
MemberInfo cookieInfo = Strong.MemberInfo((Light x) => x.cookie);
MemberInfo cookieSizeInfo = Strong.MemberInfo((Light x) => x.cookieSize);
MemberInfo flareInfo = Strong.MemberInfo((Light x) => x.flare);
MemberInfo renderModeInfo = Strong.MemberInfo((Light x) => x.renderMode);
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor("Enabled", editor.Component, enabledInfo, enabledInfo));
descriptors.Add(new PropertyDescriptor("Type", editor.Component, lightTypeInfo, lightTypeInfo, valueChanged));
if (light.type == LightType.Point)
{
MemberInfo rangeInfo = Strong.MemberInfo((Light x) => x.range);
descriptors.Add(new PropertyDescriptor("Range", editor.Component, rangeInfo, rangeInfo));
}
else if (light.type == LightType.Spot)
{
MemberInfo rangeInfo = Strong.MemberInfo((Light x) => x.range);
MemberInfo spotAngleInfo = Strong.MemberInfo((Light x) => x.spotAngle);
descriptors.Add(new PropertyDescriptor("Range", editor.Component, rangeInfo, rangeInfo));
descriptors.Add(new PropertyDescriptor("Spot Angle", editor.Component, spotAngleInfo, spotAngleInfo, null, new Range(1, 179)));
}
descriptors.Add(new PropertyDescriptor("Color", editor.Component, colorInfo, colorInfo));
descriptors.Add(new PropertyDescriptor("Intensity", editor.Component, intensityInfo, intensityInfo, null, new Range(0, 8)));
descriptors.Add(new PropertyDescriptor("Bounce Intensity", editor.Component, bounceIntensityInfo, bounceIntensityInfo, null, new Range(0, 8)));
if (light.type != LightType.Area)
{
descriptors.Add(new PropertyDescriptor("Shadow Type", editor.Component, shadowTypeInfo, shadowTypeInfo, valueChanged));
if (light.shadows == LightShadows.Soft || light.shadows == LightShadows.Hard)
{
MemberInfo shadowStrengthInfo = Strong.MemberInfo((Light x) => x.shadowStrength);
MemberInfo shadowResolutionInfo = Strong.MemberInfo((Light x) => x.shadowResolution);
MemberInfo shadowBiasInfo = Strong.MemberInfo((Light x) => x.shadowBias);
MemberInfo shadowNormalBiasInfo = Strong.MemberInfo((Light x) => x.shadowNormalBias);
MemberInfo shadowNearPlaneInfo = Strong.MemberInfo((Light x) => x.shadowNearPlane);
descriptors.Add(new PropertyDescriptor("Strength", editor.Component, shadowStrengthInfo, shadowStrengthInfo, null, new Range(0, 1)));
descriptors.Add(new PropertyDescriptor("Resoultion", editor.Component, shadowResolutionInfo, shadowResolutionInfo));
descriptors.Add(new PropertyDescriptor("Bias", editor.Component, shadowBiasInfo, shadowBiasInfo, null, new Range(0, 2)));
descriptors.Add(new PropertyDescriptor("Normal Bias", editor.Component, shadowNormalBiasInfo, shadowNormalBiasInfo, null, new Range(0, 3)));
descriptors.Add(new PropertyDescriptor("Shadow Near Plane", editor.Component, shadowNearPlaneInfo, shadowNearPlaneInfo, null, new Range(0, 10)));
}
descriptors.Add(new PropertyDescriptor("Cookie", editor.Component, cookieInfo, cookieInfo));
descriptors.Add(new PropertyDescriptor("Cookie Size", editor.Component, cookieSizeInfo, cookieSizeInfo));
}
descriptors.Add(new PropertyDescriptor("Flare", editor.Component, flareInfo, flareInfo));
descriptors.Add(new PropertyDescriptor("Render Mode", editor.Component, renderModeInfo, renderModeInfo));
return(descriptors.ToArray());
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
ILocalization lc = IOC.Resolve <ILocalization>();
bool overrideVoxelSize = editor.NotNullComponents.OfType <NavMeshSurface>().All(nms => nms.overrideVoxelSize);
bool overrideTileSize = editor.NotNullComponents.OfType <NavMeshSurface>().All(nms => nms.overrideTileSize);
MemberInfo agentTypeInfo = Strong.MemberInfo((NavMeshSurface x) => x.agentTypeID);
MemberInfo collectObjectsInfo = Strong.MemberInfo((NavMeshSurface x) => x.collectObjects);
MemberInfo useGeometryInfo = Strong.MemberInfo((NavMeshSurface x) => x.useGeometry);
MemberInfo defaultAreaInfo = Strong.MemberInfo((NavMeshSurface x) => x.defaultArea);
MemberInfo overrideVoxelSizeInfo = Strong.MemberInfo((NavMeshSurface x) => x.overrideVoxelSize);
MemberInfo voxelSizeInfo = Strong.MemberInfo((NavMeshSurface x) => x.voxelSize);
MemberInfo overrideTileSizeInfo = Strong.MemberInfo((NavMeshSurface x) => x.overrideTileSize);
MemberInfo tileSizeInfo = Strong.MemberInfo((NavMeshSurface x) => x.tileSize);
MemberInfo buildHightMesh = Strong.MemberInfo((NavMeshSurface x) => x.buildHeightMesh);
MethodInfo bakeMethodInfo = Strong.MethodInfo((NavMeshSurface x) => x.BuildNavMesh());
MethodInfo clearMethodInfo = Strong.MethodInfo((NavMeshSurface x) => x.RemoveData());
int settingsCount = NavMesh.GetSettingsCount();
RangeOptions.Option[] agentTypes = new RangeOptions.Option[settingsCount];
for (int i = 0; i < settingsCount; ++i)
{
var id = NavMesh.GetSettingsByIndex(i).agentTypeID;
var name = NavMesh.GetSettingsNameFromID(id);
agentTypes[i] = new RangeOptions.Option(name, id);
}
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_AgentType"), editor.Components, agentTypeInfo)
{
Range = new RangeOptions(agentTypes)
});
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_CollectObjects"), editor.Components, collectObjectsInfo));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_UseGeometry"), editor.Components, useGeometryInfo));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_DefaultArea"), editor.Components, defaultAreaInfo));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_OverrideVoxelSize"), editor.Components, overrideVoxelSizeInfo)
{
ValueChangedCallback = () => editor.BuildEditor()
});
if (overrideVoxelSize)
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_VoxelSize"), editor.Components, voxelSizeInfo));
}
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_OverrideTileSize"), editor.Components, overrideTileSizeInfo)
{
ValueChangedCallback = () => editor.BuildEditor()
});
if (overrideTileSize)
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_TileSize"), editor.Components, tileSizeInfo));
}
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_BuildHeightMesh"), editor.Components, buildHightMesh));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_Bake"), editor.Components, bakeMethodInfo)
{
ValueChangedCallback = () => editor.BuildEditor()
});
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTNavigation_NavMeshAgentComponentDescriptor_Clear"), editor.Components, clearMethodInfo)
{
ValueChangedCallback = () => editor.BuildEditor()
});
return(descriptors.ToArray());
}
