/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
if (p.Name == nameof(DepthMultiplier) && Texture.Value != TextureType.Depth)
{
skip = true;
return;
}
if (p.Name == nameof(MotionMultiplier) && Texture.Value != TextureType.MotionVector)
{
skip = true;
return;
}
if (p.Name == nameof(ShadowMultiplier) && !Texture.Value.ToString().Contains("Shadow"))
{
skip = true;
return;
}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
//if( p.Name == "CreateType" || p.Name == "CreateSize" || p.Name == "CreateDepth" || p.Name == "CreateMipmaps" ||
// p.Name == "CreateUsage" || p.Name == "CreateFSAA" )
//{
// if( CreateFormat.Value == PixelFormat.Unknown )
// {
// skip = true;
// return;
// }
//}
//if( p.Name == nameof( LoadFile ) )
//{
// if( CreateFormat.Value != PixelFormat.Unknown )
// {
// skip = true;
// return;
// }
//}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(Range):
if (Type != TypeEnum.Range)
{
skip = true;
}
break;
case nameof(NeoAxis.Curve):
if (Type != TypeEnum.Curve)
{
skip = true;
}
break;
}
}
}
///// <summary>
///// The background color of the application.
///// </summary>
//[Category( "Application" )]
//[DefaultValue( "transparent" )]
//public Reference<string> BackgroundColor
//{
// get { if( _backgroundColor.BeginGet() ) BackgroundColor = _backgroundColor.Get( this ); return _backgroundColor.value; }
// set { if( _backgroundColor.BeginSet( ref value ) ) { try { BackgroundColorChanged?.Invoke( this ); } finally { _backgroundColor.EndSet(); } } }
//}
///// <summary>Occurs when the <see cref="BackgroundColor"/> property value changes.</summary>
//public event Action<Component_Product_UWP> BackgroundColorChanged;
//ReferenceField<string> _backgroundColor = "transparent";
//[Category( "Application" )]
//public Reference<string> RotationPreference { get; } = ""; //TODO: implement this.
//[Category( "Application" )]
//[DefaultValue( "" )]
//public Reference<string> Capabilities
//{
// get { if( _capabilities.BeginGet() ) Capabilities = _capabilities.Get( this ); return _capabilities.value; }
// set { if( _capabilities.BeginSet( ref value ) ) { try { CapabilitiesChanged?.Invoke( this ); } finally { _capabilities.EndSet(); } } }
//}
///// <summary>Occurs when the <see cref="Capabilities"/> property value changes.</summary>
//public event Action<Component_Product_UWP> CapabilitiesChanged;
//ReferenceField<string> _capabilities = "";
//[Category( "ContentUris" )]
//[Browsable( false )]
//public Reference<string> ApplicationContentUriRules { get; set; } = ""; //TODO: implement this.
/////////////////////////////////////////
// visual assets
///// <summary>
///// When used, overrides Assets folder path.
///// </summary>
//[DefaultValue( "" )]
//[Category( "Assets" )]
////[DisplayName( "AssetsFolder" )]
//[Serialize]
//public Reference<string> AssetsFolderOverride
//{
// get { if( _assetsFolderOverride.BeginGet() ) AssetsFolderOverride = _assetsFolderOverride.Get( this ); return _assetsFolderOverride.value; }
// set { if( _assetsFolderOverride.BeginSet( ref value ) ) { try { AssetsFolderChanged?.Invoke( this ); } finally { _assetsFolderOverride.EndSet(); } } }
//}
///// <summary>Occurs when the <see cref="AssetsFolder"/> property value changes.</summary>
//public event Action<Component_Product_UWP> AssetsFolderChanged;
//ReferenceField<string> _assetsFolderOverride = "";
//string _assetsFolderDefault = @"ProjectTemplate\ProductName\Assets";
//string GetAssetsFolder()
//{
// return string.IsNullOrEmpty( AssetsFolderOverride ) ? _assetsFolderDefault : AssetsFolderOverride.Value;
//}
/////////////////////////////////////////
// build and run
//[Category( "Build and Run" )]
//[DefaultValue( "Release" )]
//public Reference<string> BuildConfiguration
//{
// get { if( _buildConfiguration.BeginGet() ) BuildConfiguration = _buildConfiguration.Get( this ); return _buildConfiguration.value; }
// set { if( _buildConfiguration.BeginSet( ref value ) ) { try { BuildConfigurationChanged?.Invoke( this ); } finally { _buildConfiguration.EndSet(); } } }
//}
///// <summary>Occurs when the <see cref="BuildConfiguration"/> property value changes.</summary>
//public event Action<Component_Product_UWP> BuildConfigurationChanged;
//ReferenceField<string> _buildConfiguration = "Release";
//[Category( "Build and Run" )]
//public string BuildConfiguration { get; } = "Debug";//TODO: implement this.
//!!!!does not work
//[Category( "Build and Run" )]
//public bool RunOnLocalMachine { get; } = true; //TODO: implement this.
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(PackageDisplayName):
case nameof(PackageVersion):
case nameof(PackagePublisher):
case nameof(PublisherDisplayName):
case nameof(AppDisplayName):
case nameof(AppDescription):
case nameof(ApplicationId):
case nameof(EntryPoint):
if (!PatchProjectFiles)
{
skip = true;
}
break;
}
}
}
//!!!!
//capture settings:
//Resolution - в анрыле это общая настройка двига. можно по ссылке указать
//Shadow Distance
//Background Color
//Use Occlusion Culling
//из CubemapZone что там?
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(Cubemap):
//case nameof( CubemapIrradiance ):
if (Mode.Value != ModeEnum.Resource)
{
skip = true;
}
break;
case nameof(Resolution):
case nameof(HDR):
//case nameof( Mipmaps ):
//case nameof( Realtime ):
case nameof(NearClipPlane):
case nameof(FarClipPlane):
case nameof(RenderSky):
if (Mode.Value != ModeEnum.Capture)
{
skip = true;
}
break;
}
}
}
//Range autoFocusRange = new Range( 1, 70 );
//[DefaultValue( typeof( Range ), "1 70" )]
//[Editor( typeof( RangeValueEditor ), typeof( UITypeEditor ) )]
//[EditorLimitsRange( 1, 200 )]
//public Range AutoFocusRange
//{
// get { return autoFocusRange; }
// set { autoFocusRange = value; }
//}
//float autoFocusTransitionSpeed = 100;
//[DefaultValue( 100.0f )]
//[Editor( typeof( SingleValueEditor ), typeof( UITypeEditor ) )]
//[EditorLimitsRange( 1, 500 )]
//public float AutoFocusTransitionSpeed
//{
// get { return autoFocusTransitionSpeed; }
// set
// {
// if( value < 0 )
// value = 0;
// autoFocusTransitionSpeed = value;
// }
//}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(ForegroundTransitionLength):
if (!BlurForeground.Value)
{
skip = true;
}
break;
case nameof(BlurDownscalingValue):
if (BlurDownscalingMode.Value == Component_RenderingPipeline_Basic.DownscalingModeEnum.Auto)
{
skip = true;
}
break;
}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(SegmentsHorizontal):
case nameof(SegmentsVertical):
if (SphereType.Value != SphereTypeEnum.GeoSphere)
{
skip = true;
}
break;
case nameof(Subdivisions):
if (SphereType.Value != SphereTypeEnum.IcoSphere)
{
skip = true;
}
break;
}
}
}
static void CheckMissingSummaries()
{
//ESet<string> toSkip = new ESet<string>();
//toSkip.Add( "NeoAxis.Component.T property: Enabled" );
//toSkip.Add( "NeoAxis.Component.T property: Name" );
bool titleWasAdded = false;
ESet <Metadata.Member> processed = new ESet <Metadata.Member>(8000);
foreach (var type in MetadataManager.NetTypes.ToArray())
{
if (typeof(Component).IsAssignableFrom(type.GetNetType()) && type.GetNetType().IsPublic)
{
Metadata.GetMembersContext context = new Metadata.GetMembersContext();
context.filter = false;
foreach (var member in type.MetadataGetMembers(context))
{
string missingText = null;
var property = member as Metadata.Property;
if (property != null && property.Browsable && !processed.Contains(property))
{
processed.AddWithCheckAlreadyContained(property);
var id = GetMemberId(member);
if (!string.IsNullOrEmpty(id))
{
if (string.IsNullOrEmpty(GetMemberSummary(id)))
{
var text = type.Name + " " + "property: " + member.Name;
//if( !toSkip.Contains( text ) )
missingText = text;
}
}
}
//!!!!events
if (missingText != null)
{
if (!titleWasAdded)
{
Log.InvisibleInfo("-----------------------------");
Log.InvisibleInfo("Missing type descriptions:");
titleWasAdded = true;
}
Log.InvisibleInfo(missingText);
}
}
}
}
if (titleWasAdded)
{
Log.InvisibleInfo("-----------------------------");
}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(StartDistance):
case nameof(Density):
if (!Mode.Value.HasFlag(Modes.Exp) && !Mode.Value.HasFlag(Modes.Exp2))
{
skip = true;
}
break;
case nameof(Height):
case nameof(HeightScale):
if (!Mode.Value.HasFlag(Modes.Height))
{
skip = true;
}
break;
}
}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(VerticalIndention):
if (!Multiline)
{
skip = true;
}
break;
case nameof(ShadowOffset):
case nameof(ShadowColor):
if (!Shadow)
{
skip = true;
}
break;
}
}
}
public IEnumerable <Metadata.Member> MetadataGetMembers(Metadata.GetMembersContext context = null)
{
foreach (var p in properties)
{
yield return(p);
}
}
public IEnumerable <Metadata.Member> MetadataGetMembers(Metadata.GetMembersContext context = null)
{
var members = new List <Metadata.Member>(BaseType.MetadataGetMembers(context));
//move CreateCSharpClass to bottom
{
var member = BaseType.MetadataGetMemberBySignature("property:" + nameof(CreateCSharpClass));
if (member != null)
{
if (members.Remove(member))
{
members.Add(member);
}
}
}
foreach (var m in members)
//foreach( var m in BaseType.MetadataGetMembers( context ) )
{
bool skip = false;
if (context == null || context.filter)
{
OnMetadataGetMembersFilter(context, m, ref skip);
}
if (!skip)
{
yield return(m);
}
}
}
/////////////////////////////////////////
//!!!!
//public class NewObjectSettingsProperty : NewObjectSettings
//{
// bool createFlowGraphWithGetSetAccessors = false;
// [DefaultValue( false )]
// [Category( "Options" )]
// public bool CreateFlowGraphWithGetSetAccessors
// {
// get { return createFlowGraphWithGetSetAccessors; }
// set { createFlowGraphWithGetSetAccessors = value; }
// }
// public override bool Creation( NewObjectCell.ObjectCreationContext context )
// {
// var property = (Component_Property)context.newObject;
// if( CreateFlowGraphWithGetSetAccessors )
// {
// var graph = property.CreateComponent<Component_FlowGraph>();
// graph.Name = "Flow Graph";
// Component_MethodBody bodyGet;
// {
// var node = graph.CreateComponent<Component_FlowGraphNode>();
// bodyGet = node.CreateComponent<Component_MethodBody>();
// bodyGet.Name = "Method Body Get";
// bodyGet.PropertyAccessorType = Component_MethodBody.PropertyAccessorTypeEnum.Get;
// node.Name = "Node " + bodyGet.Name;
// node.Position = new Vector2I( -25, -12 );
// node.ControlledObject = new Reference<Component>( null, ReferenceUtility.CalculateThisReference( node, bodyGet ) );
// }
// Component_MethodBodyEnd bodyEndGet;
// {
// var node = graph.CreateComponent<Component_FlowGraphNode>();
// bodyEndGet = node.CreateComponent<Component_MethodBodyEnd>();
// bodyEndGet.Name = "Method Body Get End";
// node.Name = "Node " + bodyEndGet.Name + " Get";
// node.Position = new Vector2I( 15, -12 );
// node.ControlledObject = new Reference<Component>( null, ReferenceUtility.CalculateThisReference( node, bodyEndGet ) );
// }
// Component_MethodBody bodySet;
// {
// var node = graph.CreateComponent<Component_FlowGraphNode>();
// bodySet = node.CreateComponent<Component_MethodBody>();
// bodySet.Name = "Method Body Set";
// bodySet.PropertyAccessorType = Component_MethodBody.PropertyAccessorTypeEnum.Set;
// node.Name = "Node " + bodySet.Name + " Set";
// node.Position = new Vector2I( -25, 8 );
// node.ControlledObject = new Reference<Component>( null, ReferenceUtility.CalculateThisReference( node, bodySet ) );
// }
// property.GetAccessor = new Reference<Component_MethodBody>( null, ReferenceUtility.CalculateThisReference( property, bodyGet ) );
// property.SetAccessor = new Reference<Component_MethodBody>( null, ReferenceUtility.CalculateThisReference( property, bodySet ) );
// bodyGet.Definition = new Reference<Component_Member>( null, ReferenceUtility.CalculateThisReference( bodyGet, property ) );
// bodyGet.BodyEnd = new Reference<Component_MethodBodyEnd>( null, ReferenceUtility.CalculateThisReference( bodyGet, bodyEndGet ) );
// bodyEndGet.Body = new Reference<Component_MethodBody>( null, ReferenceUtility.CalculateThisReference( bodyEndGet, bodyGet ) );
// bodySet.Definition = new Reference<Component_Member>( null, ReferenceUtility.CalculateThisReference( bodySet, property ) );
// //!!!!выделять, открывать созданные
// }
// return true;
// }
//}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
//!!!!slowly?
//!!!!так?
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case "DefaultValue":
if (!DefaultValueSpecified.Value)
{
skip = true;
}
break;
case "SetAccessor":
if (ReadOnly)
{
skip = true;
}
break;
}
}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(LimitLow):
case nameof(LimitHigh):
if (!LimitEnabled)
{
skip = true;
}
break;
case nameof(MotorSpeed):
case nameof(MotorMaxTorque):
if (!MotorEnabled)
{
skip = true;
}
break;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(Mass):
case nameof(Inertia):
case nameof(EnableGravity):
case nameof(LinearDamping):
case nameof(AngularDamping):
case nameof(LinearVelocity):
case nameof(AngularVelocity):
case nameof(AllowSleep):
case nameof(LocalCenter):
case nameof(CCD):
case nameof(FixedRotation):
if (MotionType.Value != MotionTypeEnum.Dynamic)
{
skip = true;
}
break;
}
}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(Texture):
if (TextureType.Value == TextureTypeEnum.Mask)
{
skip = true;
}
break;
case nameof(Location2):
if (TextureType.Value != TextureTypeEnum.Mask)
{
var t = Texture.Value;
if (t == null || t.Result == null || t.Result.TextureType != Component_Image.TypeEnum._2D)
{
skip = true;
return;
}
}
break;
case nameof(Location3):
{
var t = Texture.Value;
if (t == null || t.Result == null ||
(t.Result.TextureType != Component_Image.TypeEnum.Cube && t.Result.TextureType != Component_Image.TypeEnum._3D))
{
skip = true;
return;
}
}
break;
case nameof(RGBA):
case nameof(G):
case nameof(B):
case nameof(A):
{
var result = Texture.Value?.Result;
if (result != null && (result.ResultFormat == PixelFormat.L8 || result.ResultFormat == PixelFormat.L16))
//if( t == null || t.Result == null || ( t.Result.ResultFormat == PixelFormat.L8 || t.Result.ResultFormat == PixelFormat.L16 ) )
{
skip = true;
return;
}
}
break;
}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
switch (p.Name)
{
case nameof(CreateType):
case nameof(CreateSize):
case nameof(CreateDepth):
case nameof(CreateArrayLayers):
case nameof(CreateMipmaps):
case nameof(CreateUsage):
case nameof(CreateFSAA):
if (CreateFormat.Value == PixelFormat.Unknown)
{
skip = true;
}
if (p.Name == nameof(CreateDepth) && CreateType.Value != TypeEnum._3D)
{
skip = true;
}
break;
case nameof(LoadFile):
if (CreateFormat.Value != PixelFormat.Unknown)
{
skip = true;
}
if (AnyCubemapSideIsSpecified())
{
skip = true;
}
break;
case nameof(LoadCubePositiveX):
case nameof(LoadCubeNegativeX):
case nameof(LoadCubePositiveY):
case nameof(LoadCubeNegativeY):
case nameof(LoadCubePositiveZ):
case nameof(LoadCubeNegativeZ):
if (CreateFormat.Value != PixelFormat.Unknown)
{
skip = true;
}
if (LoadFile.Value != null)
{
skip = true;
}
break;
}
}
}
public Metadata.Member MetadataGetMemberBySignature(string signature, Metadata.GetMembersContext context = null)
{
foreach (var p in properties)
{
if (p.Signature == signature)
{
return(p);
}
}
return(null);
}
//void MetadataGetMembersFilter( Metadata.GetMembersContext context, Metadata.Member member, ref bool skip )
//{
// var p = member as Metadata.Property;
// if( p != null )
// {
// switch( p.Name )
// {
// case nameof( PanelMode_Resources ):
// if( owner.Mode != ContentBrowser.ModeEnum.Resources )
// skip = true;
// break;
// case nameof( PanelMode_Objects ):
// if( owner.Mode != ContentBrowser.ModeEnum.Objects )
// skip = true;
// break;
// case nameof( PanelMode_SetReference ):
// if( owner.Mode != ContentBrowser.ModeEnum.SetReference )
// skip = true;
// break;
// case nameof( ListMode ):
// case nameof( ListIconSize ):
// case nameof( Breadcrumb ):
// if( PanelMode == ContentBrowser.PanelModeEnum.Tree )
// skip = true;
// break;
// case nameof( EditorButton ):
// case nameof( SettingsButton ):
// if( !DisplayPropertiesEditorSettingsButtons )
// skip = true;
// break;
// case nameof( FilteringModeButton ):
// if( owner.Mode != ContentBrowser.ModeEnum.Resources )
// skip = true;
// break;
// case nameof( MembersButton ):
// if( owner.Mode != ContentBrowser.ModeEnum.Objects )
// skip = true;
// break;
// case nameof( SortFilesBy ):
// case nameof( SortFilesByAscending ):
// if( !DisplayPropertiesSortFilesBy )
// skip = true;
// break;
// case nameof( OpenButton ):
// if( !DisplayPropertiesOpenButton )
// skip = true;
// break;
// }
// }
//}
public IEnumerable <Metadata.Member> MetadataGetMembers(Metadata.GetMembersContext context = null)
{
foreach (var m in BaseType.MetadataGetMembers(context))
{
//bool skip = false;
//if( context == null || context.filter )
// MetadataGetMembersFilter( context, m, ref skip );
//if( !skip )
yield return(m);
}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(CollisionsBetweenLinkedBodies):
skip = true;
break;
}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
//var p = member as Metadata.Property;
//if( p != null )
//{
// switch( p.Name )
// {
// case nameof( SpotlightInnerAngle ):
// if( Type.Value != TypeEnum.Spotlight )
// skip = true;
// break;
//}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
var p = member as Metadata.Property;
if (p != null)
{
if (p.Name == nameof(VertexStructure) || p.Name == nameof(UnwrappedUV) || p.Name == nameof(Vertices) || p.Name == nameof(Indices))
{
skip = true;
return;
}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (UserMode)
{
if (member is Metadata.Property)
{
if (member.Name == "Name" || member.Name == "Enabled" || member.Name == "ScreenLabel")
{
skip = true;
}
}
}
}
///////////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
//if( member is Metadata.Property )
//{
// switch( member.Name )
// {
// case nameof( RoundedLineCurvatureRadius ):
// if( CurveTypePosition.Value != CurveTypeEnum.RoundedLine )
// skip = true;
// break;
// }
//}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
//if( member is Metadata.Property )
//{
//switch( member.Name )
//{
//case nameof( BreakingImpulseThreshold ):
//case nameof( OverrideNumberSolverIterations ):
// if( SoftBodyMode )
// skip = true;
// break;
//}
//}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(PathfindingSpecific):
if (!Pathfinding)
{
skip = true;
}
break;
}
}
}
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(ShadowOffset):
if (!CastShadows)
{
skip = true;
}
break;
}
}
}
///////////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(Cost):
if (License.Value != LicenseEnum.PaidPerSeat)
{
skip = true;
}
break;
}
}
}
//
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(FillTransparentPixelsByNearPixels):
if (Mode.Value != ModeEnum.Material)
{
skip = true;
}
break;
}
}
}
/////////////////////////////////////////
protected override void OnMetadataGetMembersFilter(Metadata.GetMembersContext context, Metadata.Member member, ref bool skip)
{
base.OnMetadataGetMembersFilter(context, member, ref skip);
//!!!!
//var p = member as Metadata.Property;
//if( p != null )
//{
// switch( p.Name )
// {
// case "PropertyAccessorType":
// if( Owner.Value as Component_Property == null )
// skip = true;
// break;
// }
//}
}
