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 void Init(object target, object accessor,
MemberInfo memberInfo,
Action <object, object> eraseTargetCallback = null,
string label = null,
PropertyEditorCallback valueChangingCallback = null,
PropertyEditorCallback valueChangedCallback = null,
PropertyEditorCallback endEditCallback = null,
bool enableUndo = true,
PropertyDescriptor[] childDescriptors = null,
PropertyEditorCallback beginRecordCallback = null,
PropertyEditorCallback endRecordCallback = null,
PropertyEditorCallback afterRedoCallback = null,
PropertyEditorCallback afterUndoCallback = null)
{
m_enableUndo = enableUndo;
m_valueChangingCallback = valueChangingCallback;
m_valueChangedCallback = valueChangedCallback;
m_endEditCallback = endEditCallback;
m_beginRecordCallback = beginRecordCallback;
m_endRecordCallback = endRecordCallback;
m_afterRedoCallback = afterRedoCallback;
m_afterUndoCallback = afterUndoCallback;
if (childDescriptors != null)
{
m_childDescriptors = childDescriptors.ToDictionary(d => d.MemberInfo);
}
m_lockValue = true;
InitOverride(target, accessor, memberInfo, eraseTargetCallback, label);
m_lockValue = false;
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
Camera camera = (Camera)editor.Component;
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo projection = Strong.PropertyInfo((CameraPropertyConverter x) => x.Projection, "Projection");
MemberInfo orthographic = Strong.PropertyInfo((Camera x) => x.orthographic, "orthographic");
MemberInfo fov = Strong.PropertyInfo((Camera x) => x.fieldOfView, "fieldOfView");
MemberInfo orthographicSize = Strong.PropertyInfo((Camera x) => x.orthographicSize, "orthographicSize");
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor("Projection", converter, projection, orthographic, valueChanged));
if (!camera.orthographic)
{
descriptors.Add(new PropertyDescriptor("Field Of View", editor.Component, fov, fov));
}
else
{
descriptors.Add(new PropertyDescriptor("Size", editor.Component, orthographicSize, orthographicSize));
}
return(descriptors.ToArray());
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
ILocalization lc = IOC.Resolve <ILocalization>();
Camera camera = (Camera)editor.Component;
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo projection = Strong.PropertyInfo((CameraPropertyConverter x) => x.Projection, "Projection");
MemberInfo orthographic = Strong.PropertyInfo((Camera x) => x.orthographic, "orthographic");
MemberInfo fov = Strong.PropertyInfo((Camera x) => x.fieldOfView, "fieldOfView");
MemberInfo orthographicSize = Strong.PropertyInfo((Camera x) => x.orthographicSize, "orthographicSize");
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Projection", "Projection"), converter, projection, orthographic, valueChanged));
if (!camera.orthographic)
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Fov", "Field Of View"), editor.Component, fov, "field of view"));
}
else
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Size", "Size"), editor.Component, orthographicSize, "orthographic size"));
}
return(descriptors.ToArray());
}
public void Init(object target, MemberInfo memberInfo, string label, bool enableUndo = true,
PropertyEditorCallback beginRecordCallback = null,
PropertyEditorCallback endRecordCallback = null,
PropertyEditorCallback afterRedoCallback = null,
PropertyEditorCallback afterUndoCallback = null)
{
Init(target, target, memberInfo, null, label, null, null, null, enableUndo, null, beginRecordCallback, endRecordCallback, afterRedoCallback, afterUndoCallback);
}
public MaterialPropertyDescriptor(object target, string label, ProcPropertyDescription procDescription, PropertyInfo propertyInfo, PropertyEditorCallback callback)
{
Target = target;
Label = label;
Type = RTShaderPropertyType.Procedural;
ProceduralDescription = procDescription;
PropertyInfo = propertyInfo;
ValueChangedCallback = callback;
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
object[] converters = (object[])converter;
ILocalization lc = IOC.Resolve <ILocalization>();
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo projection = Strong.PropertyInfo((CameraPropertyConverter x) => x.Projection, "Projection");
MemberInfo orthographic = Strong.PropertyInfo((Camera x) => x.orthographic, "orthographic");
MemberInfo fov = Strong.PropertyInfo((Camera x) => x.fieldOfView, "fieldOfView");
MemberInfo orthographicSize = Strong.PropertyInfo((Camera x) => x.orthographicSize, "orthographicSize");
MemberInfo cullingMask = Strong.PropertyInfo((Camera x) => x.cullingMask, "cullingMask");
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Projection", "Projection"), converters, projection, orthographic, valueChanged));
Camera[] cameras = editor.NotNullComponents.OfType <Camera>().ToArray();
if (cameras.Length > 0)
{
bool isCameraOrthographic = cameras[0].orthographic;
for (int i = 1; i < cameras.Length; ++i)
{
if (cameras[i].orthographic != isCameraOrthographic)
{
return(descriptors.ToArray());
}
}
if (!isCameraOrthographic)
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Fov", "Field Of View"), editor.Components, fov, "field of view"));
}
else
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Size", "Size"), editor.Components, orthographicSize, "orthographic size"));
}
List <RangeOptions.Option> flags = new List <RangeOptions.Option>();
LayersInfo layersInfo = LayersEditor.LoadedLayers;
foreach (LayersInfo.Layer layer in layersInfo.Layers)
{
if (!string.IsNullOrEmpty(layer.Name))
{
flags.Add(new RangeOptions.Option(layer.Name, layer.Index));
}
}
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_CullingMask", "Culling Mask"), editor.Components, cullingMask)
{
Range = new RangeFlags(flags.ToArray())
});
}
return(descriptors.ToArray());
}
public PropertyDescriptor(string label, object target, MemberInfo memberInfo, MemberInfo componentMemberInfo, PropertyEditorCallback valueChangedCallback, Range range)
{
MemberInfo = memberInfo;
ComponentMemberInfo = componentMemberInfo;
Label = label;
Target = target;
ValueChangedCallback = valueChangedCallback;
Range = range;
ChildDesciptors = null;
}
public MaterialPropertyDescriptor(object target, string label, RTShaderPropertyType type, PropertyInfo propertyInfo, RuntimeShaderInfo.RangeLimits limits, TextureDimension dims, PropertyEditorCallback callback)
{
Target = target;
Label = label;
Type = type;
PropertyInfo = propertyInfo;
Limits = limits;
TexDims = dims;
ValueChangedCallback = callback;
}
public PropertyDescriptor(string label, object target, MemberInfo memberInfo)
{
MemberInfo = memberInfo;
ComponentMemberInfo = memberInfo;
Label = label;
Target = target;
ValueChangedCallback = null;
Range = null;
ChildDesciptors = null;
}
public PropertyDescriptor(string label, object target, MemberInfo memberInfo, MemberInfo componentMemberInfo, PropertyEditorCallback valueChangedCallback, PropertyEditorCallback endEditCallback)
{
MemberInfo = memberInfo;
ComponentMemberInfo = componentMemberInfo;
Label = label;
Target = target;
ValueChangedCallback = valueChangedCallback;
EndEditCallback = endEditCallback;
Range = TryGetRange(memberInfo);
ChildDesciptors = null;
}
public PropertyDescriptor(string label, object target, MemberInfo memberInfo, MemberInfo componentMemberInfo)
{
MemberInfo = memberInfo;
ComponentMemberInfo = componentMemberInfo;
Label = label;
Target = target;
ValueChangedCallback = null;
EndEditCallback = null;
Range = TryGetRange(memberInfo);
ChildDesciptors = null;
AnimationPropertyName = null;
}
public MaterialPropertyDescriptor(object[] targets, object[] acessors, string label, RTShaderPropertyType type, PropertyInfo propertyInfo, RuntimeShaderInfo.RangeLimits limits, TextureDimension dims, PropertyEditorCallback callback, Action <object, object> eraseTargetCallback)
{
Targets = targets;
Accessors = acessors;
Label = label;
Type = type;
PropertyInfo = propertyInfo;
Limits = limits;
TexDims = dims;
ValueChangedCallback = callback;
EraseTargetCallback = eraseTargetCallback;
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
ILocalization lc = IOC.Resolve <ILocalization>();
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo convexInfo = Strong.PropertyInfo((MeshCollider x) => x.convex, "convex");
MemberInfo isTriggerInfo = Strong.PropertyInfo((MeshCollider x) => x.isTrigger, "isTrigger");
MemberInfo materialInfo = Strong.PropertyInfo((MeshCollider x) => x.sharedMaterial, "sharedMaterial");
MemberInfo meshInfo = Strong.PropertyInfo((MeshCollider x) => x.sharedMesh, "sharedMesh");
bool?hasMixedValues;
bool isConvex = GetIsConvex(editor, out hasMixedValues);
if (hasMixedValues != null)
{
if (isConvex && hasMixedValues == false)
{
return(new[]
{
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Convex", "Convex"), editor.Components, convexInfo, convexInfo, valueChanged)
{
AnimationPropertyName = "m_Convex"
},
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_IsTrigger", "Is Trigger"), editor.Components, isTriggerInfo, "m_IsTrigger"),
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Material", "Material"), editor.Components, materialInfo, materialInfo),
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Mesh", "Mesh"), editor.Components, meshInfo, meshInfo),
});
}
return(new[]
{
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Convex", "Convex"), editor.Components, convexInfo, convexInfo, valueChanged)
{
AnimationPropertyName = "m_Convex"
},
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Material", "Material"), editor.Components, materialInfo, materialInfo),
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Mesh", "Mesh"), editor.Components, meshInfo, meshInfo),
});
}
return(new PropertyDescriptor[0]);
}
public void Init(object[] targets, object[] accessors,
MemberInfo memberInfo,
Action <object, object> eraseTargetCallback = null,
string label = null,
PropertyEditorCallback valueChangingCallback = null,
PropertyEditorCallback valueChangedCallback = null,
PropertyEditorCallback endEditCallback = null,
bool enableUndo = true,
PropertyDescriptor[] childDescriptors = null,
PropertyEditorCallback beginRecordCallback = null,
PropertyEditorCallback endRecordCallback = null,
PropertyEditorCallback afterRedoCallback = null,
PropertyEditorCallback afterUndoCallback = null,
PropertyEditorCallback reloadCallback = null)
{
m_enableUndo = enableUndo;
m_valueChangingCallback = valueChangingCallback;
m_valueChangedCallback = valueChangedCallback;
m_endEditCallback = endEditCallback;
m_beginRecordCallback = beginRecordCallback;
m_endRecordCallback = endRecordCallback;
m_afterRedoCallback = afterRedoCallback;
m_afterUndoCallback = afterUndoCallback;
m_reloadCallback = reloadCallback;
if (childDescriptors != null)
{
m_childDescriptors = childDescriptors.ToDictionary(d => d.MemberInfo);
}
m_lockValue = true;
InitOverride(targets, accessors, memberInfo, eraseTargetCallback, label);
#pragma warning disable 0618
if (targets != null && accessors != null)
{
InitOverride(targets[0], accessors[0], memberInfo, eraseTargetCallback, label);
}
#pragma warning restore 0618
m_lockValue = false;
}
public void Init(object target,
MemberInfo memberInfo,
string label = null,
PropertyEditorCallback valueChangingCallback = null,
PropertyEditorCallback valueChangedCallback = null,
PropertyEditorCallback endEditCallback = null,
bool enableUndo = true,
PropertyDescriptor[] childDescriptors = null)
{
m_enableUndo = enableUndo;
m_valueChangingCallback = valueChangingCallback;
m_valueChangedCallback = valueChangedCallback;
m_endEditCallback = endEditCallback;
if (childDescriptors != null)
{
m_childDescriptors = childDescriptors.ToDictionary(d => d.MemberInfo);
}
m_lockValue = true;
InitOverride(target, memberInfo, label);
m_lockValue = false;
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
object[] converters = (object[])converter;
ILocalization lc = IOC.Resolve <ILocalization>();
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo projection = Strong.PropertyInfo((CameraPropertyConverter x) => x.Projection, "Projection");
MemberInfo orthographic = Strong.PropertyInfo((Camera x) => x.orthographic, "orthographic");
MemberInfo fov = Strong.PropertyInfo((Camera x) => x.fieldOfView, "fieldOfView");
MemberInfo orthographicSize = Strong.PropertyInfo((Camera x) => x.orthographicSize, "orthographicSize");
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Projection", "Projection"), converters, projection, orthographic, valueChanged));
Camera[] cameras = editor.NotNullComponents.OfType <Camera>().ToArray();
if (cameras.Length > 0)
{
bool isCameraOrthographic = cameras[0].orthographic;
for (int i = 1; i < cameras.Length; ++i)
{
if (cameras[i].orthographic != isCameraOrthographic)
{
return(descriptors.ToArray());
}
}
if (!isCameraOrthographic)
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Fov", "Field Of View"), editor.Components, fov, "field of view"));
}
else
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Camera_Size", "Size"), editor.Components, orthographicSize, "orthographic size"));
}
}
return(descriptors.ToArray());
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
ILocalization lc = IOC.Resolve <ILocalization>();
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo convexInfo = Strong.PropertyInfo((MeshCollider x) => x.convex, "convex");
MemberInfo isTriggerInfo = Strong.PropertyInfo((MeshCollider x) => x.isTrigger, "isTrigger");
MemberInfo materialInfo = Strong.PropertyInfo((MeshCollider x) => x.sharedMaterial, "sharedMaterial");
MemberInfo meshInfo = Strong.PropertyInfo((MeshCollider x) => x.sharedMesh, "sharedMesh");
MeshCollider collider = (MeshCollider)editor.Component;
if (collider.convex)
{
return(new[]
{
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Convex", "Convex"), editor.Component, convexInfo, convexInfo, valueChanged)
{
AnimationPropertyName = "m_Convex"
},
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_IsTrigger", "Is Trigger"), editor.Component, isTriggerInfo, "m_IsTrigger"),
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Material", "Material"), editor.Component, materialInfo, materialInfo),
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Mesh", "Mesh"), editor.Component, meshInfo, meshInfo),
});
}
else
{
return(new[]
{
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Convex", "Convex"), editor.Component, convexInfo, convexInfo, valueChanged)
{
AnimationPropertyName = "m_Convex"
},
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Material", "Material"), editor.Component, materialInfo, materialInfo),
new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_MeshCollider_Mesh", "Mesh"), editor.Component, meshInfo, meshInfo),
});
}
}
public void Init(object target, object accessor,
MemberInfo memberInfo,
Action <object, object> eraseTargetCallback = null,
string label = null,
PropertyEditorCallback valueChangingCallback = null,
PropertyEditorCallback valueChangedCallback = null,
PropertyEditorCallback endEditCallback = null,
bool enableUndo = true,
PropertyDescriptor[] childDescriptors = null,
PropertyEditorCallback beginRecordCallback = null,
PropertyEditorCallback endRecordCallback = null,
PropertyEditorCallback afterRedoCallback = null,
PropertyEditorCallback afterUndoCallback = null)
{
Init(new[] { target }, new[] { accessor }, memberInfo,
eraseTargetCallback,
label,
valueChangingCallback, valueChangedCallback, endEditCallback,
enableUndo,
childDescriptors,
beginRecordCallback, endRecordCallback,
afterRedoCallback, afterUndoCallback);
}
public MaterialPropertyDescriptor[] GetProperties(MaterialEditor editor, object converterObject)
{
PropertyEditorCallback valueChangedCallback = () => editor.BuildEditor();
StandardMaterialValueConverter converter = (StandardMaterialValueConverter)converterObject;
PropertyInfo modeInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.Mode, "Mode");
PropertyInfo cutoffInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.Cutoff, "Cutoff");
PropertyInfo metallicMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.MetallicGlossMap, "MetallicGlossMap");
PropertyInfo bumpMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.BumpMap, "BumpMap");
PropertyInfo parallaxMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.ParallaxMap, "ParallaxMap");
PropertyInfo occlusionMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.OcclusionMap, "OcclusionMap");
PropertyInfo emissionMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.EmissionMap, "EmissionMap");
PropertyInfo emissionColorInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.EmissionColor, "EmissionColor");
PropertyInfo detailMaskInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.DetailMask, "DetailMask");
PropertyInfo detailAlbedoMap = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.DetailAlbedoMap, "DetailAlbedoMap");
PropertyInfo detailNormalMap = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.DetailNormalMap, "DetailNormalMap");
// PropertyInfo uvSecondaryInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.UVSecondary);
PropertyInfo texInfo = Strong.PropertyInfo((MaterialPropertyAccessor x) => x.Texture, "Texture");
PropertyInfo colorInfo = Strong.PropertyInfo((MaterialPropertyAccessor x) => x.Color, "Color");
PropertyInfo floatInfo = Strong.PropertyInfo((MaterialPropertyAccessor x) => x.Float, "Float");
BlendMode mode = GetBlendMode(editor.Material);
List <MaterialPropertyDescriptor> properties = new List <MaterialPropertyDescriptor>();
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Rendering Mode", RTShaderPropertyType.Float, modeInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.None, valueChangedCallback, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _MainTex), "Albedo", RTShaderPropertyType.TexEnv, texInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _Color), "Albedo Color", RTShaderPropertyType.Color, colorInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.None, null, EraseAccessorTarget));
if (mode == BlendMode.Cutout)
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Alpha Cutoff", RTShaderPropertyType.Range, cutoffInfo, new RuntimeShaderInfo.RangeLimits(0.5f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Metallic", RTShaderPropertyType.TexEnv, metallicMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
bool hasGlossMap = IsMetallicGlossMapSet(editor.Material);
if (!hasGlossMap)
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _Metallic), "Metallic", RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
if (StandardMaterialValueConverter.GetSmoothnessMapChannel(editor.Material) == StandardMaterialValueConverter.SmoothnessMapChannel.SpecularMetallicAlpha)
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _Glossiness), "Smoothness", RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(0.5f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
else
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _GlossMapScale), "Smoothness", RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(1.0f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
}
else
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _GlossMapScale), "Smoothness", RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(1.0f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Normal Map", RTShaderPropertyType.TexEnv, bumpMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
if (converter.BumpMap != null)
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _BumpScale), "Normal Map Scale", RTShaderPropertyType.Float, floatInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Height Map", RTShaderPropertyType.TexEnv, parallaxMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
if (converter.ParallaxMap != null)
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _Parallax), "Height Map Scale", RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(0.02f, 0.005f, 0.08f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Occlusion Map", RTShaderPropertyType.TexEnv, occlusionMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
if (converter.OcclusionMap != null)
{
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _OcclusionStrength), "Occlusion Strength", RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(1.0f, 0, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Emission Map", RTShaderPropertyType.TexEnv, emissionMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Emission Color", RTShaderPropertyType.Color, emissionColorInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.None, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Detail Mask", RTShaderPropertyType.TexEnv, detailMaskInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Detail Albedo Map", RTShaderPropertyType.TexEnv, detailAlbedoMap, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, converter, "Detail Normal Map", RTShaderPropertyType.TexEnv, detailNormalMap, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Material, new MaterialPropertyAccessor(editor.Material, _DetailNormalMapScale), "Detail Scale", RTShaderPropertyType.Float, floatInfo, new RuntimeShaderInfo.RangeLimits(0, 0, 0), TextureDimension.None, null, EraseAccessorTarget));
return(properties.ToArray());
}
public MaterialPropertyDescriptor[] GetProperties(MaterialEditor editor, object converterObject)
{
ILocalization lc = IOC.Resolve <ILocalization>();
PropertyEditorCallback valueChangedCallback = () => editor.BuildEditor();
StandardMaterialValueConverter[] converters = ((object[])converterObject).Cast <StandardMaterialValueConverter>().ToArray();
PropertyInfo modeInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.Mode, "Mode");
PropertyInfo cutoffInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.Cutoff, "Cutoff");
PropertyInfo metallicMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.MetallicGlossMap, "MetallicGlossMap");
PropertyInfo bumpMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.BumpMap, "BumpMap");
PropertyInfo parallaxMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.ParallaxMap, "ParallaxMap");
PropertyInfo occlusionMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.OcclusionMap, "OcclusionMap");
PropertyInfo emissionMapInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.EmissionMap, "EmissionMap");
PropertyInfo emissionColorInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.EmissionColor, "EmissionColor");
PropertyInfo detailMaskInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.DetailMask, "DetailMask");
PropertyInfo detailAlbedoMap = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.DetailAlbedoMap, "DetailAlbedoMap");
PropertyInfo detailNormalMap = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.DetailNormalMap, "DetailNormalMap");
PropertyInfo texInfo = Strong.PropertyInfo((MaterialPropertyAccessor x) => x.Texture, "Texture");
PropertyInfo colorInfo = Strong.PropertyInfo((MaterialPropertyAccessor x) => x.Color, "Color");
PropertyInfo floatInfo = Strong.PropertyInfo((MaterialPropertyAccessor x) => x.Float, "Float");
BlendMode?mode = (BlendMode?)GetValue(editor.Materials, GetBlendMode);
List <MaterialPropertyDescriptor> properties = new List <MaterialPropertyDescriptor>();
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_RenderingMode", "Rendering Mode"), RTShaderPropertyType.Float, modeInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.None, valueChangedCallback, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _MainTex), lc.GetString("ID_RTEditor_CD_StandardMaterial_Albedo", "Albedo"), RTShaderPropertyType.TexEnv, texInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _Color), lc.GetString("ID_RTEditor_CD_StandardMaterial_AlbedoColor", "Albedo Color"), RTShaderPropertyType.Color, colorInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.None, null, EraseAccessorTarget));
if (mode == BlendMode.Cutout)
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_AlphaCutoff", "Alpha Cutoff"), RTShaderPropertyType.Range, cutoffInfo, new RuntimeShaderInfo.RangeLimits(0.5f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_Metallic", "Metallic"), RTShaderPropertyType.TexEnv, metallicMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
bool?hasGlossMap = (bool?)GetValue(editor.Materials, IsMetallicGlossMapSet);
if (hasGlossMap != null)
{
if (!hasGlossMap.Value)
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _Metallic), lc.GetString("ID_RTEditor_CD_StandardMaterial_Metallic", "Metallic"), RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
var smoothness = (StandardMaterialUtils.SmoothnessMapChannel?)GetValue(editor.Materials, material => StandardMaterialUtils.GetSmoothnessMapChannel(material));
if (smoothness != null)
{
if (smoothness.Value == StandardMaterialUtils.SmoothnessMapChannel.SpecularMetallicAlpha)
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _Glossiness), lc.GetString("ID_RTEditor_CD_StandardMaterial_Smoothness", "Smoothness"), RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(0.5f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
else
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _GlossMapScale), lc.GetString("ID_RTEditor_CD_StandardMaterial_Smoothness", "Smoothness"), RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(1.0f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
}
}
else
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _GlossMapScale), lc.GetString("ID_RTEditor_CD_StandardMaterial_Smoothness", "Smoothness"), RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(1.0f, 0.0f, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
}
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_NormalMap", "Normal Map"), RTShaderPropertyType.TexEnv, bumpMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
bool?hasBumpMap = (bool?)GetValue(converters, conv => conv.BumpMap != null);
if (hasBumpMap != null && hasBumpMap.Value)
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _BumpScale), lc.GetString("ID_RTEditor_CD_StandardMaterial_NormalMapScale", "Normal Map Scale"), RTShaderPropertyType.Float, floatInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_HeightMap", "Height Map"), RTShaderPropertyType.TexEnv, parallaxMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
bool?hasParallaxMap = (bool?)GetValue(converters, conv => conv.ParallaxMap != null);
if (hasParallaxMap != null && hasParallaxMap.Value)
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _Parallax), lc.GetString("ID_RTEditor_CD_StandardMaterial_HeightMapScale", "Height Map Scale"), RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(0.02f, 0.005f, 0.08f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_OcclusionMap", "Occlusion Map"), RTShaderPropertyType.TexEnv, occlusionMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, valueChangedCallback, EraseAccessorTarget));
bool?occlusionMap = (bool?)GetValue(converters, conv => conv.OcclusionMap != null);
if (occlusionMap != null && occlusionMap.Value)
{
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _OcclusionStrength), lc.GetString("ID_RTEditor_CD_StandardMaterial_OcclusionStrength", "Occlusion Strength"), RTShaderPropertyType.Range, floatInfo, new RuntimeShaderInfo.RangeLimits(1.0f, 0, 1.0f), TextureDimension.None, null, EraseAccessorTarget));
}
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_EmissionMap", "Emission Map"), RTShaderPropertyType.TexEnv, emissionMapInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_EmissionMap", "Emission Color"), RTShaderPropertyType.Color, emissionColorInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.None, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_DetailMask", "Detail Mask"), RTShaderPropertyType.TexEnv, detailMaskInfo, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_DetailAlbedoMap", "Detail Albedo Map"), RTShaderPropertyType.TexEnv, detailAlbedoMap, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_DetailNormalMap", "Detail Normal Map"), RTShaderPropertyType.TexEnv, detailNormalMap, new RuntimeShaderInfo.RangeLimits(0.0f, 0.0f, 0.0f), TextureDimension.Tex2D, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, CreateAccessors(editor, _DetailNormalMapScale), lc.GetString("ID_RTEditor_CD_StandardMaterial_DetailScale", "Detail Scale"), RTShaderPropertyType.Float, floatInfo, new RuntimeShaderInfo.RangeLimits(0, 0, 0), TextureDimension.None, null, EraseAccessorTarget));
PropertyInfo tilingInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.Tiling, "Tiling");
PropertyInfo offsetInfo = Strong.PropertyInfo((StandardMaterialValueConverter x) => x.Offset, "Offset");
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_Tiling", "Tiling"), RTShaderPropertyType.Vector, tilingInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.None, null, EraseAccessorTarget));
properties.Add(new MaterialPropertyDescriptor(editor.Materials, converters, lc.GetString("ID_RTEditor_CD_StandardMaterial_Offset", "Offset"), RTShaderPropertyType.Vector, offsetInfo, new RuntimeShaderInfo.RangeLimits(), TextureDimension.None, null, EraseAccessorTarget));
return(properties.ToArray());
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
Light light = (Light)editor.Component;
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo enabledInfo = Strong.PropertyInfo((Light x) => x.enabled, "enabled");
MemberInfo lightTypeInfo = Strong.PropertyInfo((Light x) => x.type, "type");
MemberInfo colorInfo = Strong.PropertyInfo((Light x) => x.color, "color");
MemberInfo intensityInfo = Strong.PropertyInfo((Light x) => x.intensity, "intensity");
MemberInfo bounceIntensityInfo = Strong.PropertyInfo((Light x) => x.bounceIntensity, "bounceIntensity");
MemberInfo shadowTypeInfo = Strong.PropertyInfo((Light x) => x.shadows, "shadows");
MemberInfo cookieInfo = Strong.PropertyInfo((Light x) => x.cookie, "cookie");
MemberInfo cookieSizeInfo = Strong.PropertyInfo((Light x) => x.cookieSize, "cookieSize");
MemberInfo flareInfo = Strong.PropertyInfo((Light x) => x.flare, "flare");
MemberInfo renderModeInfo = Strong.PropertyInfo((Light x) => x.renderMode, "renderMode");
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor("Enabled", editor.Component, enabledInfo, "m_Enabled"));
descriptors.Add(new PropertyDescriptor("Type", editor.Component, lightTypeInfo, lightTypeInfo, valueChanged));
if (light.type == LightType.Point)
{
MemberInfo rangeInfo = Strong.PropertyInfo((Light x) => x.range, "range");
descriptors.Add(new PropertyDescriptor("Range", editor.Component, rangeInfo, "m_Range"));
}
else if (light.type == LightType.Spot)
{
MemberInfo rangeInfo = Strong.PropertyInfo((Light x) => x.range, "range");
MemberInfo spotAngleInfo = Strong.PropertyInfo((Light x) => x.spotAngle, "spotAngle");
descriptors.Add(new PropertyDescriptor("Range", editor.Component, rangeInfo, "m_Range"));
descriptors.Add(new PropertyDescriptor("Spot Angle", editor.Component, spotAngleInfo, spotAngleInfo, null, new Range(1, 179))
{
AnimationPropertyName = "m_SpotAngle"
});
}
descriptors.Add(new PropertyDescriptor("Color", editor.Component, colorInfo, "m_Color"));
descriptors.Add(new PropertyDescriptor("Intensity", editor.Component, intensityInfo, intensityInfo, null, new Range(0, 8))
{
AnimationPropertyName = "m_Intensity"
});
descriptors.Add(new PropertyDescriptor("Bounce Intensity", editor.Component, bounceIntensityInfo, bounceIntensityInfo, null, new Range(0, 8))
{
AnimationPropertyName = "m_BounceIntensity"
});
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.PropertyInfo((Light x) => x.shadowStrength, "shadowStrength");
MemberInfo shadowResolutionInfo = Strong.PropertyInfo((Light x) => x.shadowResolution, "shadowResolution");
MemberInfo shadowBiasInfo = Strong.PropertyInfo((Light x) => x.shadowBias, "shadowBias");
MemberInfo shadowNormalBiasInfo = Strong.PropertyInfo((Light x) => x.shadowNormalBias, "shadowNormalBias");
MemberInfo shadowNearPlaneInfo = Strong.PropertyInfo((Light x) => x.shadowNearPlane, "shadowNearPlane");
descriptors.Add(new PropertyDescriptor("Strength", editor.Component, shadowStrengthInfo, shadowStrengthInfo, null, new Range(0, 1))
{
AnimationPropertyName = "m_Strength"
});
descriptors.Add(new PropertyDescriptor("Resoultion", editor.Component, shadowResolutionInfo, shadowResolutionInfo));
descriptors.Add(new PropertyDescriptor("Bias", editor.Component, shadowBiasInfo, shadowBiasInfo, null, new Range(0, 2))
{
AnimationPropertyName = "m_Bias"
});
descriptors.Add(new PropertyDescriptor("Normal Bias", editor.Component, shadowNormalBiasInfo, shadowNormalBiasInfo, null, new Range(0, 3))
{
AnimationPropertyName = "m_NormalBias"
});
descriptors.Add(new PropertyDescriptor("Shadow Near Plane", editor.Component, shadowNearPlaneInfo, shadowNearPlaneInfo, null, new Range(0, 10))
{
AnimationPropertyName = "m_NearPlane"
});
}
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 MaterialPropertyDescriptor(object target, object acessor, string label, RTShaderPropertyType type, PropertyInfo propertyInfo, RuntimeShaderInfo.RangeLimits limits, TextureDimension dims, PropertyEditorCallback callback, Action <object, object> eraseTargetCallback)
: this(new[] { target }, new[] { acessor }, label, type, propertyInfo, limits, dims, callback, eraseTargetCallback)
{
}
public PropertyDescriptor(string label, object[] targets, MemberInfo memberInfo, MemberInfo componentMemberInfo, PropertyEditorCallback valueChangedCallback, Range range)
: this(label, targets, memberInfo, componentMemberInfo, valueChangedCallback, (PropertyEditorCallback)null)
{
Range = range;
}
public PropertyDescriptor(string label, object target, MemberInfo memberInfo, MemberInfo componentMemberInfo, PropertyEditorCallback valueChangedCallback, PropertyEditorCallback endEditCallback)
: this(label, new[] { target }, memberInfo, componentMemberInfo, valueChangedCallback, endEditCallback)
{
}
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter)
{
ILocalization lc = IOC.Resolve <ILocalization>();
PropertyEditorCallback valueChanged = () => editor.BuildEditor();
MemberInfo enabledInfo = Strong.PropertyInfo((Light x) => x.enabled, "enabled");
MemberInfo lightTypeInfo = Strong.PropertyInfo((Light x) => x.type, "type");
MemberInfo colorInfo = Strong.PropertyInfo((Light x) => x.color, "color");
MemberInfo intensityInfo = Strong.PropertyInfo((Light x) => x.intensity, "intensity");
MemberInfo bounceIntensityInfo = Strong.PropertyInfo((Light x) => x.bounceIntensity, "bounceIntensity");
MemberInfo shadowTypeInfo = Strong.PropertyInfo((Light x) => x.shadows, "shadows");
MemberInfo cookieInfo = Strong.PropertyInfo((Light x) => x.cookie, "cookie");
MemberInfo cookieSizeInfo = Strong.PropertyInfo((Light x) => x.cookieSize, "cookieSize");
MemberInfo flareInfo = Strong.PropertyInfo((Light x) => x.flare, "flare");
MemberInfo renderModeInfo = Strong.PropertyInfo((Light x) => x.renderMode, "renderMode");
bool? hasMixedLightTypes;
LightType lightType = GetLightType(editor, out hasMixedLightTypes);
List <PropertyDescriptor> descriptors = new List <PropertyDescriptor>();
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Enabled", "Enabled"), editor.Components, enabledInfo, "m_Enabled"));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Type", "Type"), editor.Components, lightTypeInfo, lightTypeInfo, valueChanged));
if (hasMixedLightTypes == false)
{
if (lightType == LightType.Point)
{
MemberInfo rangeInfo = Strong.PropertyInfo((Light x) => x.range, "range");
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Range", "Range"), editor.Components, rangeInfo, "m_Range"));
}
else if (lightType == LightType.Spot)
{
MemberInfo rangeInfo = Strong.PropertyInfo((Light x) => x.range, "range");
MemberInfo spotAngleInfo = Strong.PropertyInfo((Light x) => x.spotAngle, "spotAngle");
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Range", "Range"), editor.Components, rangeInfo, "m_Range"));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_SpotAngle", "Spot Angle"), editor.Components, spotAngleInfo, spotAngleInfo, null, new Range(1, 179))
{
AnimationPropertyName = "m_SpotAngle"
});
}
}
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Color", "Color"), editor.Components, colorInfo, "m_Color"));
Range lightIntensityRange = RenderPipelineInfo.Type == RPType.HDRP ? new Range(0, 128000) : new Range(0, 8);
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Intensity", "Intensity"), editor.Components, intensityInfo, intensityInfo, null, lightIntensityRange)
{
AnimationPropertyName = "m_Intensity"
});
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_BounceIntensity", "Bounce Intensity"), editor.Components, bounceIntensityInfo, bounceIntensityInfo, null, new Range(0, 8))
{
AnimationPropertyName = "m_BounceIntensity"
});
if (hasMixedLightTypes == false)
{
if (lightType != LightType.Area)
{
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_ShadowType", "Shadow Type"), editor.Components, shadowTypeInfo, shadowTypeInfo, valueChanged));
bool? hasMixedLightShadows;
LightShadows lightShadows = GetLightShadows(editor, out hasMixedLightShadows);
if (hasMixedLightShadows == false && (lightShadows == LightShadows.Soft || lightShadows == LightShadows.Hard))
{
MemberInfo shadowStrengthInfo = Strong.PropertyInfo((Light x) => x.shadowStrength, "shadowStrength");
MemberInfo shadowResolutionInfo = Strong.PropertyInfo((Light x) => x.shadowResolution, "shadowResolution");
MemberInfo shadowBiasInfo = Strong.PropertyInfo((Light x) => x.shadowBias, "shadowBias");
MemberInfo shadowNormalBiasInfo = Strong.PropertyInfo((Light x) => x.shadowNormalBias, "shadowNormalBias");
MemberInfo shadowNearPlaneInfo = Strong.PropertyInfo((Light x) => x.shadowNearPlane, "shadowNearPlane");
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Strength", "Strength"), editor.Components, shadowStrengthInfo, shadowStrengthInfo, null, new Range(0, 1))
{
AnimationPropertyName = "m_Strength"
});
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Resolution", "Resoultion"), editor.Components, shadowResolutionInfo, shadowResolutionInfo));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Bias", "Bias"), editor.Components, shadowBiasInfo, shadowBiasInfo, null, new Range(0, 2))
{
AnimationPropertyName = "m_Bias"
});
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_NormalBias", "Normal Bias"), editor.Components, shadowNormalBiasInfo, shadowNormalBiasInfo, null, new Range(0, 3))
{
AnimationPropertyName = "m_NormalBias"
});
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_ShadowNearPlane", "Shadow Near Plane"), editor.Components, shadowNearPlaneInfo, shadowNearPlaneInfo, null, new Range(0, 10))
{
AnimationPropertyName = "m_NearPlane"
});
}
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Cookie", "Cookie"), editor.Components, cookieInfo, cookieInfo));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_CookieSize", "Cookie Size"), editor.Components, cookieSizeInfo, cookieSizeInfo));
}
}
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_Flare", "Flare"), editor.Components, flareInfo, flareInfo));
descriptors.Add(new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_Light_RenderMode", "Render Mode"), editor.Components, renderModeInfo, renderModeInfo));
return(descriptors.ToArray());
}
