static int GetMemberTypeSortIndex(Metadata.Member member)
{
//!!!!другие типы тоже
if (member is Metadata.Property)
{
return(0);
}
if (member is Metadata.Method)
{
if (((Metadata.Method)member).Constructor)
{
return(1);
}
else
{
return(2);
}
}
if (member is Metadata.Event)
{
return(3);
}
return(100);
}
void Clear()
{
memberObject = null;
properties.Clear();
propertyBySignature.Clear();
propertyMethodParameters = null;
//propertyMethodReturnParameter = null;
propertyPropertyValue = null;
}
//!!!!ValueTuple<object, Metadata.Property>
//!!!!new. так оставить?
public void GetMember(object owner, out object outObject, out Metadata.Member outMember)
{
if (!string.IsNullOrEmpty(getByReference))
{
MetadataManager.GetMemberByReference(typeof(T), owner, getByReference, out outObject, out outMember);
}
else
{
outObject = null;
outMember = null;
}
}
//!!!!new. тут?
public static string GetUserFriendlyCategory(Metadata.Member member)
{
var ar = member.GetCustomAttributes(typeof(CategoryAttribute), true);
if (ar.Length != 0)
{
return(((CategoryAttribute)ar[0]).Category);
}
{
//if( property.Creator == null )
// throw new ArgumentException( "property.Creator == null" );
var category = member.Owner.ToString();
//!!!!
{
int index = category.LastIndexOf('_');
if (index != -1)
{
category = category.Substring(index + 1);
}
}
//!!!!
{
//string[] prefixes = new string[ 2 ];
//prefixes[ 0 ] = "NeoAxis.";
//prefixes[ 1 ] = "UI";
foreach (var prefix in prefixesToRemove)
//foreach( var prefix in prefixes )
{
if (category.Length > prefix.Length && category.Substring(0, prefix.Length) == prefix)
{
category = category.Substring(prefix.Length);
}
}
}
////!!!!почему только этот префикс
//{
// string prefix = "NeoAxis.";
// if( category.Length > prefix.Length && category.Substring( 0, prefix.Length ) == prefix )
// category = category.Substring( prefix.Length );
//}
category = DisplayNameAddSpaces(category);
return(category);
}
}
public static bool IsMemberVisible(Metadata.Member member)
{
if (member is Metadata.Property property)
{
return(property.Browsable && !property.HasIndexers && !property.Static /*!!!! && !property.ReadOnly */);
}
else if (member is Metadata.Event evnt)
{
return(!evnt.Static);
}
Log.Fatal("internal error.");
return(true);
}
public virtual Type GetSuitableItemType(Metadata.Member member)
{
Type itemType = null;
//override item type
GetSuitableItemTypeOverride?.Invoke(this, member, ref itemType);
if (itemType == null)
{
var editorAttr = (EditorAttribute)member.GetCustomAttributes(typeof(EditorAttribute), true).FirstOrDefault();
if (editorAttr != null)
{
var editorType = EditorUtility.GetTypeByName(editorAttr.EditorTypeName);
if (typeof(HCItemProperty).IsAssignableFrom(editorType))
{
return(editorType);
}
}
var property = member as Metadata.Property;
if (property != null)
{
//var attribs = property.GetCustomAttributes( typeof( SelectBaseAttribute ), true );
//if( attribs.Length != 0 )
//{
// //get item type by SelectBaseAttribute
// var attrib = (SelectBaseAttribute)attribs[ 0 ];
// itemType = attrib.GetHierarchicalContainerItemType();
//}
//else
//{
//get item type by property type
var originalType = property.Type.GetNetType();
var unrefType = ReferenceUtility.GetUnreferencedType(originalType);
itemType = GetSuitableItemTypeByPropertyType(unrefType);
//}
}
var _event = member as Metadata.Event;
if (_event != null)
{
return(EditorAssemblyInterface.Instance.GetTypeByName("NeoAxis.Editor.HCItemEvent")); // typeof( HCItemEvent );
}
}
return(itemType);
}
public static bool IsMemberVisible(object obj, Metadata.Member member)
{
bool result = true;
if (member is Metadata.Property property)
{
result = property.Browsable && !property.HasIndexers && !property.Static /*!!!! && !property.ReadOnly */;
}
else if (member is Metadata.Event evnt)
{
result = !evnt.Static;
}
else
{
Log.Fatal("internal error.");
}
IsMemberVisibleOverride?.Invoke(obj, member, ref result);
return(result);
}
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;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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 (!Shadows.Value && p.Name.Length > 6 && p.Name.Substring(0, 6) == "Shadow" && p.Name != nameof(Shadows))
{
skip = true;
return;
}
switch (p.Name)
{
//case nameof( ShadowDirectionalLightCascadesSplit1 ):
// if( ShadowDirectionalLightCascades.Value < 2 )
// skip = true;
// break;
//case nameof( ShadowDirectionalLightCascadesSplit2 ):
// if( ShadowDirectionalLightCascades.Value < 3 )
// skip = true;
// break;
//case nameof( ShadowDirectionalLightCascadesSplit3 ):
// if( ShadowDirectionalLightCascades.Value < 4 )
// skip = true;
// break;
case nameof(ShadowDirectionalLightCascadeDistribution):
case nameof(ShadowDirectionalLightCascadeVisualize):
if (ShadowDirectionalLightCascades.Value < 2)
{
skip = true;
}
break;
}
}
}
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);
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);
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;
}
}
}
////!!!!
//[Category( "Exposure" )]
//[DefaultValue( 1.0 )]
//[Range( 0, 10, RangeAttribute.ConvenientDistributionEnum.Exponential )]
//public Reference<double> EmissiveMaterialsFactor
//{
// get { if( _emissiveMaterialsFactor.BeginGet() ) EmissiveMaterialsFactor = _emissiveMaterialsFactor.Get( this ); return _emissiveMaterialsFactor.value; }
// set { if( _emissiveMaterialsFactor.BeginSet( ref value ) ) { try { EmissiveMaterialsFactorChanged?.Invoke( this ); } finally { _emissiveMaterialsFactor.EndSet(); } } }
//}
//public event Action<Component_Camera> EmissiveMaterialsFactorChanged;
//ReferenceField<double> _emissiveMaterialsFactor = 1.0;
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)
{
if (p.Name == "FieldOfView" && Projection.Value != ProjectionType.Perspective)
{
skip = true;
return;
}
if (p.Name == "Height" && Projection.Value != ProjectionType.Orthographic)
{
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(BlurDownscalingValue):
if (BlurDownscalingMode.Value == Component_RenderingPipeline_Basic.DownscalingModeEnum.Auto)
{
skip = true;
}
break;
}
}
}
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(TileImageSize):
case nameof(ListImageSize):
case nameof(ListColumnWidth):
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 || !AllowFilteringModeButton)
{
skip = true;
}
break;
case nameof(MembersButton):
if (owner.Mode != ContentBrowser.ModeEnum.Objects || !AllowMembersButton)
{
skip = true;
}
break;
case nameof(SortFilesBy):
case nameof(SortFilesByAscending):
if (!DisplayPropertiesSortFilesBy)
{
skip = true;
}
break;
case nameof(OpenButton):
if (!DisplayPropertiesOpenButton)
{
skip = true;
}
break;
case nameof(SearchButton):
if (owner.Mode != ContentBrowser.ModeEnum.Objects)
{
skip = true;
}
break;
case nameof(SearchBar):
skip = true;
break;
case nameof(SplitterPosition):
if (PanelMode == ContentBrowser.PanelModeEnum.Tree || PanelMode == ContentBrowser.PanelModeEnum.List)
{
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(DownscaleSamplerMultiplier):
case nameof(DownscaleBeforeSceneEffects):
if (Technique.Value == TechniqueEnum.None || Technique.Value == TechniqueEnum.FXAA /*|| ( Technique.Value >= TechniqueEnum.MSAAx2 && Technique.Value <= TechniqueEnum.MSAAx16 ) */)
{
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(Shape):
{
var geometryType = Type.Value;
if (geometryType == TypeEnum.BakedObstacle || geometryType == TypeEnum.TemporaryObstacle)
{
skip = true;
}
}
break;
}
}
}
public static bool TypeSettingsPrivateObjectsContains(string[] typeSettingsPrivateObjects, Metadata.Member member)
{
if (typeSettingsPrivateObjects != null)
{
foreach (var name in typeSettingsPrivateObjects)
{
if (name == member.Name)
{
return(true);
}
}
}
return(false);
}
///////////////////////////////////////////////
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(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);
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;
}
}
}
void Update()
{
//check disabled
if (!Enabled)
{
Clear();
return;
}
//get actual member
Metadata.Member newMemberObject = GetNeededMember();
//check for updates
if (!needUpdate && newMemberObject != memberObject)
{
needUpdate = true;
}
//nothing to update
if (!needUpdate)
{
return;
}
//do update
Clear();
memberObject = newMemberObject;
needUpdate = false;
if (memberObject != null)
{
//method
var method = memberObject as Metadata.Method;
if (method != null)
{
//parameters
propertyMethodParameters = new List <PropertyImpl>();
int invokeParameterIndexCounter = 0;
for (int nParameter = 0; nParameter < method.Parameters.Length; nParameter++)
{
var parameter = method.Parameters[nParameter];
if (parameter.ByReference || parameter.Output || parameter.ReturnValue)
{
//!!!!имя еще как-то фиксить?
//string name = null;
////!!!!так?
//if( parameter.ReturnValue )
// name = "Return";
//if( name == null )
var name = parameter.Name.Substring(0, 1).ToUpper() + parameter.Name.Substring(1);
//name = parameter.Name;
Type unrefNetType = parameter.Type.GetNetType();
var refNetType = typeof(Reference <>).MakeGenericType(unrefNetType);
var type = MetadataManager.GetTypeOfNetType(refNetType);
PropertyImpl.ParameterType parameterType;
if (parameter.ReturnValue)
{
parameterType = PropertyImpl.ParameterType.ReturnValue;
}
else
{
parameterType = PropertyImpl.ParameterType.Parameter;
}
string namePrefix = "__parameter_";
string displayName = TypeUtility.DisplayNameAddSpaces(name);
var p = new PropertyImpl(this, namePrefix + name, false, type, parameter.Type, new Metadata.Parameter[0], false, "Parameters", displayName, parameterType, invokeParameterIndexCounter);
p.Description = "";
p.Serializable = SerializeType.Enable;
properties.Add(p);
propertyBySignature[p.Signature] = p;
//if( parameter.ReturnValue )
// propertyMethodOutputParameter = p;
//else
propertyMethodParameters.Add(p);
}
if (!parameter.ReturnValue)
{
invokeParameterIndexCounter++;
}
}
}
//property
var property = memberObject as Metadata.Property;
if (property != null)
{
//value
var body = Body.Value;
if (body.PropertyAccessorType.Value == Component_MethodBody.PropertyAccessorTypeEnum.Get)
{
Type unrefNetType = property.TypeUnreferenced.GetNetType();
var refNetType = typeof(Reference <>).MakeGenericType(unrefNetType);
var type = MetadataManager.GetTypeOfNetType(refNetType);
string namePrefix = "__value_";
var p = new PropertyImpl(this, namePrefix + "ReturnValue", false, type, property.TypeUnreferenced, new Metadata.Parameter[0], false, "Members", "Return Value", PropertyImpl.ParameterType.ReturnValue, 0);
p.Description = "";
p.Serializable = SerializeType.Enable;
properties.Add(p);
propertyBySignature[p.Signature] = p;
propertyPropertyValue = p;
}
}
//!!!!другие
}
}
/////////////////////////////////////////
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(FreeCameraHotKeyValue):
if (!FreeCameraHotKey)
{
skip = true;
}
break;
case nameof(ThirdPersonCameraHorizontalAngle):
case nameof(ThirdPersonCameraVerticalAngle):
case nameof(ThirdPersonCameraDistance):
if (UseBuiltInCamera.Value != BuiltInCameraEnum.ThirdPerson)
{
skip = true;
}
break;
case nameof(DisplayTargetSize):
case nameof(DisplayTargetImage):
case nameof(DisplayTargetColor):
if (!DisplayTarget)
{
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(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(Material):
if (Surface.Value != null)
{
skip = true;
}
break;
case nameof(Surface):
if (Material.Value != null)
{
skip = true;
}
break;
case nameof(Mask):
if (MaskImage.Value != null)
{
skip = true;
}
break;
case nameof(MaskImage):
if (Mask.Value != null && Mask.Value.Length != 0)
{
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(InstancingMinCount):
case nameof(InstancingMaxCount):
case nameof(InstancingTransparent):
if (!Instancing)
{
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);
if (member is Metadata.Property)
{
switch (member.Name)
{
case nameof(RayTarget):
if (Shape.Value != ShapeEnum.Ray)
{
skip = true;
}
break;
case nameof(PhysicsFilterGroup):
case nameof(PhysicsFilterMask):
if (SourceData.Value != SourceDataEnum.PhysicsObjects)
{
skip = true;
}
break;
case nameof(IgnoreSensors):
if (SourceData.Value != SourceDataEnum.ObjectsInSpace)
{
skip = true;
}
break;
case nameof(ConvexSweepTarget):
if (!(Shape.Value == ShapeEnum.Box || Shape.Value == ShapeEnum.Sphere))
{
skip = true;
}
break;
}
}
}
static FastNoise()
{
int metadataCount = fnGetMetadataCount();
nodeMetadata = new Metadata[metadataCount];
metadataNameLookup = new Dictionary <string, int>(metadataCount);
// Collect metadata for all FastNoise node classes
for (int id = 0; id < metadataCount; id++)
{
Metadata metadata = new Metadata();
metadata.id = id;
metadata.name = FormatLookup(Marshal.PtrToStringAnsi(fnGetMetadataName(id)));
//Console.WriteLine(id + " - " + metadata.name);
metadataNameLookup.Add(metadata.name, id);
int variableCount = fnGetMetadataVariableCount(id);
int nodeLookupCount = fnGetMetadataNodeLookupCount(id);
int hybridCount = fnGetMetadataHybridCount(id);
metadata.members = new Dictionary <string, Metadata.Member>(variableCount + nodeLookupCount + hybridCount);
// Init variables
for (int variableIdx = 0; variableIdx < variableCount; variableIdx++)
{
Metadata.Member member = new Metadata.Member();
member.name = FormatLookup(Marshal.PtrToStringAnsi(fnGetMetadataVariableName(id, variableIdx)));
member.type = (Metadata.Member.Type)fnGetMetadataVariableType(id, variableIdx);
member.index = variableIdx;
member.name = FormatDimensionMember(member.name, fnGetMetadataVariableDimensionIdx(id, variableIdx));
// Get enum names
if (member.type == Metadata.Member.Type.Enum)
{
int enumCount = fnGetMetadataEnumCount(id, variableIdx);
member.enumNames = new Dictionary <string, int>(enumCount);
for (int enumIdx = 0; enumIdx < enumCount; enumIdx++)
{
member.enumNames.Add(FormatLookup(Marshal.PtrToStringAnsi(fnGetMetadataEnumName(id, variableIdx, enumIdx))), enumIdx);
}
}
metadata.members.Add(member.name, member);
}
// Init node lookups
for (int nodeLookupIdx = 0; nodeLookupIdx < nodeLookupCount; nodeLookupIdx++)
{
Metadata.Member member = new Metadata.Member();
member.name = FormatLookup(Marshal.PtrToStringAnsi(fnGetMetadataNodeLookupName(id, nodeLookupIdx)));
member.type = Metadata.Member.Type.NodeLookup;
member.index = nodeLookupIdx;
member.name = FormatDimensionMember(member.name, fnGetMetadataNodeLookupDimensionIdx(id, nodeLookupIdx));
metadata.members.Add(member.name, member);
}
// Init hybrids
for (int hybridIdx = 0; hybridIdx < hybridCount; hybridIdx++)
{
Metadata.Member member = new Metadata.Member();
member.name = FormatLookup(Marshal.PtrToStringAnsi(fnGetMetadataHybridName(id, hybridIdx)));
member.type = Metadata.Member.Type.Hybrid;
member.index = hybridIdx;
member.name = FormatDimensionMember(member.name, fnGetMetadataHybridDimensionIdx(id, hybridIdx));
metadata.members.Add(member.name, member);
}
nodeMetadata[id] = metadata;
}
}
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;
}
}
}
