public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
if (IsColor32(container.ExportVersion))
{
node.Add(Key0Name, ((ColorRGBA32)Key0).ExportYAML(container));
node.Add(Key1Name, ((ColorRGBA32)Key1).ExportYAML(container));
node.Add(Key2Name, ((ColorRGBA32)Key2).ExportYAML(container));
node.Add(Key3Name, ((ColorRGBA32)Key3).ExportYAML(container));
node.Add(Key4Name, ((ColorRGBA32)Key4).ExportYAML(container));
node.Add(Key5Name, ((ColorRGBA32)Key5).ExportYAML(container));
node.Add(Key6Name, ((ColorRGBA32)Key6).ExportYAML(container));
node.Add(Key7Name, ((ColorRGBA32)Key7).ExportYAML(container));
}
else
{
node.Add(Key0Name, Key0.ExportYAML(container));
node.Add(Key1Name, Key1.ExportYAML(container));
node.Add(Key2Name, Key2.ExportYAML(container));
node.Add(Key3Name, Key3.ExportYAML(container));
node.Add(Key4Name, Key4.ExportYAML(container));
node.Add(Key5Name, Key5.ExportYAML(container));
node.Add(Key6Name, Key6.ExportYAML(container));
node.Add(Key7Name, Key7.ExportYAML(container));
}
node.Add(Ctime0Name, Ctime0);
node.Add(Ctime1Name, Ctime1);
node.Add(Ctime2Name, Ctime2);
node.Add(Ctime3Name, Ctime3);
node.Add(Ctime4Name, Ctime4);
node.Add(Ctime5Name, Ctime5);
node.Add(Ctime6Name, Ctime6);
node.Add(Ctime7Name, Ctime7);
node.Add(Atime0Name, Atime0);
node.Add(Atime1Name, Atime1);
node.Add(Atime2Name, Atime2);
node.Add(Atime3Name, Atime3);
node.Add(Atime4Name, Atime4);
node.Add(Atime5Name, Atime5);
node.Add(Atime6Name, Atime6);
node.Add(Atime7Name, Atime7);
if (HasMode(container.ExportVersion))
{
node.Add(ModeName, (int)Mode);
}
node.Add(NumColorKeysName, NumColorKeys);
node.Add(NumAlphaKeysName, NumAlphaKeys);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add(MinDistanceName, MinDistance);
node.Add(MaxDistanceName, MaxDistance);
node.Add(ReverbPresetName, ReverbPreset);
node.Add(RoomName, Room);
node.Add(RoomHFName, RoomHF);
node.Add(DecayTimeName, DecayTime);
node.Add(DecayHFRatioName, DecayHFRatio);
node.Add(ReflectionsName, Reflections);
node.Add(ReflectionsDelayName, ReflectionsDelay);
node.Add(ReverbName, Reverb);
node.Add(ReverbDelayName, ReverbDelay);
node.Add(HFReferenceName, HFReference);
node.Add(DiffusionName, Diffusion);
node.Add(DensityName, Density);
node.Add(LFReferenceName, LFReference);
node.Add(RoomLFName, RoomLF);
return(node);
}
public override YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = (YAMLMappingNode)base.ExportYAML(container);
node.Add(StrengthName, Strength.ExportYAML(container));
node.Add(StrengthYName, StrengthY.ExportYAML(container));
node.Add(StrengthZName, StrengthZ.ExportYAML(container));
node.Add(SeparateAxesName, SeparateAxes);
node.Add(FrequencyName, Frequency);
node.Add(DampingName, Damping);
node.Add(OctavesName, Octaves);
node.Add(OctaveMultiplierName, OctaveMultiplier);
node.Add(OctaveScaleName, OctaveScale);
node.Add(QualityName, (int)Quality);
node.Add(ScrollSpeedName, ScrollSpeed.ExportYAML(container));
node.Add(RemapName, Remap.ExportYAML(container));
node.Add(RemapYName, RemapY.ExportYAML(container));
node.Add(RemapZName, RemapZ.ExportYAML(container));
node.Add(RemapEnabledName, RemapEnabled);
node.Add(PositionAmountName, GetExportPositionAmount(container.Version).ExportYAML(container));
node.Add(RotationAmountName, GetExportRotationAmount(container.Version).ExportYAML(container));
node.Add(SizeAmountName, GetExportSizeAmount(container.Version).ExportYAML(container));
return(node);
}
public override YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = (YAMLMappingNode)base.ExportYAML(container);
node.InsertSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(StartLifetimeName, StartLifetime.ExportYAML(container));
node.Add(StartSpeedName, StartSpeed.ExportYAML(container));
node.Add(StartColorName, StartColor.ExportYAML(container));
node.Add(StartSizeName, StartSize.ExportYAML(container));
node.Add(StartSizeYName, GetStartSizeY(container.Version).ExportYAML(container));
node.Add(StartSizeZName, GetStartSizeZ(container.Version).ExportYAML(container));
node.Add(StartRotationXName, GetStartRotationX(container.Version).ExportYAML(container));
node.Add(StartRotationYName, GetStartRotationY(container.Version).ExportYAML(container));
node.Add(StartRotationName, StartRotation.ExportYAML(container));
node.Add(RandomizeRotationDirectionName, RandomizeRotationDirection);
node.Add(MaxNumParticlesName, MaxNumParticles);
node.Add(Size3DName, Size3D);
node.Add(Rotation3DName, Rotation3D);
node.Add(GravityModifierName, GravityModifier.ExportYAML(container));
return(node);
}
protected override void ExportYAMLInner(IExportContainer container, YAMLMappingNode node)
{
base.ExportYAMLInner(container, node);
SpriteMetaData[] sprites = new SpriteMetaData[m_sprites.Count];
for (int i = 0; i < m_sprites.Count; i++)
{
sprites[i] = new SpriteMetaData(m_sprites[i]);
}
node.AddSerializedVersion(GetSerializedVersion(container.Version));
YAMLMappingNode mipmap = new YAMLMappingNode();
mipmap.Add("mipMapMode", (int)TextureImporterMipFilter.BoxFilter);
mipmap.Add("enableMipMap", m_texture.MipCount > 1 ? true : false);
mipmap.Add("sRGBTexture", m_texture.ColorSpace == ColorSpace.Gamma ? true : false);
mipmap.Add("linearTexture", false);
mipmap.Add("fadeOut", false);
mipmap.Add("borderMipMap", false);
mipmap.Add("mipMapsPreserveCoverage", false);
mipmap.Add("alphaTestReferenceValue", 0.5f);
mipmap.Add("mipMapFadeDistanceStart", 1);
mipmap.Add("mipMapFadeDistanceEnd", 3);
node.Add("mipmaps", mipmap);
YAMLMappingNode bumpmap = new YAMLMappingNode();
bumpmap.Add("convertToNormalMap", false);
bumpmap.Add("externalNormalMap", false);
bumpmap.Add("heightScale", 0.25f);
bumpmap.Add("normalMapFilter", (int)TextureImporterNormalFilter.Standard);
node.Add("bumpmap", bumpmap);
node.Add("isReadable", m_texture.IsReadable);
node.Add("grayScaleToAlpha", false);
node.Add("generateCubemap", (int)TextureImporterGenerateCubemap.AutoCubemap);
node.Add("cubemapConvolution", 0);
node.Add("seamlessCubemap", false);
node.Add("textureFormat", (int)m_texture.TextureFormat);
int maxSize = m_texture.Width > m_texture.Height ? m_texture.Width : m_texture.Height;
maxSize = maxSize > 2048 ? maxSize : 2048;
node.Add("maxTextureSize", maxSize);
TextureImportSettings importSettings = new TextureImportSettings(m_texture.TextureSettings);
node.Add("textureSettings", importSettings.ExportYAML(container));
node.Add("nPOTScale", false);
node.Add("lightmap", false);
node.Add("compressionQuality", 50);
SpriteImportMode spriteMode;
switch (m_sprites.Count)
{
case 0:
spriteMode = SpriteImportMode.Single;
break;
case 1:
Sprite sprite = m_sprites[0];
if (sprite.Rect == sprite.RD.TextureRect)
{
spriteMode = sprite.Name == m_texture.Name ? SpriteImportMode.Single : SpriteImportMode.Multiple;
}
else
{
spriteMode = SpriteImportMode.Multiple;
}
break;
default:
spriteMode = SpriteImportMode.Multiple;
break;
}
node.Add("spriteMode", (int)spriteMode);
node.Add("spriteExtrude", 1);
node.Add("spriteMeshType", (int)SpriteMeshType.Tight);
node.Add("alignment", 0);
Vector2f pivot = new Vector2f(0.5f, 0.5f);
node.Add("spritePivot", pivot.ExportYAML(container));
node.Add("spriteBorder", default(Rectf).ExportYAML(container));
node.Add("spritePixelsToUnits", 100);
node.Add("alphaUsage", true);
node.Add("alphaIsTransparency", true);
node.Add("spriteTessellationDetail", -1);
TextureImporterType type;
if (m_texture.LightmapFormat.IsNormalmap())
{
type = TextureImporterType.NormalMap;
}
else
{
type = m_sprites.Count == 0 ? TextureImporterType.Default : TextureImporterType.Sprite;
}
node.Add("textureType", (int)type);
TextureImporterShape shape = (m_texture is Cubemap) ? TextureImporterShape.TextureCube : TextureImporterShape.Texture2D;
node.Add("textureShape", (int)shape);
node.Add("maxTextureSizeSet", false);
node.Add("compressionQualitySet", false);
node.Add("textureFormatSet", false);
TextureImporterPlatformSettings platform = new TextureImporterPlatformSettings();
TextureImporterPlatformSettings[] platforms = new TextureImporterPlatformSettings[] { platform };
node.Add("platformSettings", platforms.ExportYAML(container));
SpriteSheetMetaData spriteSheet;
if (spriteMode == SpriteImportMode.Single)
{
if (sprites.Length == 0)
{
spriteSheet = new SpriteSheetMetaData(sprites);
}
else
{
spriteSheet = new SpriteSheetMetaData(sprites[0]);
}
}
else
{
spriteSheet = new SpriteSheetMetaData(sprites);
}
node.Add("spriteSheet", spriteSheet.ExportYAML(container));
node.Add("spritePackingTag", string.Empty);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(WidthName, Width);
node.Add(HeightName, Height);
node.Add(CompleteImageSizeName, CompleteImageSize);
node.Add(TextureFormatName, (int)TextureFormat);
node.Add(MipCountName, MipCount);
node.Add(IsReadableName, IsReadable);
if (HasStreamingMipmaps(container.ExportVersion))
{
node.Add(StreamingMipmapsName, StreamingMipmaps);
}
if (HasStreamingMipmapsPriority(container.ExportVersion))
{
node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority);
}
node.Add(AlphaIsTransparencyName, GetAlphaIsTransparency(container.Version, container.Flags));
node.Add(ImageCountName, ImageCount);
node.Add(TextureDimensionName, (int)TextureDimension);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(LightmapFormatName, (int)LightmapFormat);
node.Add(ColorSpaceName, (int)ColorSpace);
IReadOnlyList <byte> imageData = GetExportImageData();
node.Add(ImageDataName, imageData.Count);
node.Add(TypelessdataName, imageData.ExportYAML());
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(PatchesName, Patches.ExportYAML(container));
node.Add(DetailPrototypesName, DetailPrototypes.ExportYAML(container));
node.Add(PatchCountName, PatchCount);
node.Add(PatchSamplesName, PatchSamples);
node.Add(RandomRotationsName, RandomRotations.ExportYAML(container));
node.Add(WavingGrassTintName, WavingGrassTint.ExportYAML(container));
node.Add(WavingGrassStrengthName, WavingGrassStrength);
node.Add(WavingGrassAmountName, WavingGrassAmount);
node.Add(WavingGrassSpeedName, WavingGrassSpeed);
node.Add(TreeInstancesName, TreeInstances.ExportYAML(container));
node.Add(TreePrototypesName, TreePrototypes.ExportYAML(container));
node.Add(PreloadTextureAtlasDataName, PreloadTextureAtlasData.ExportYAML(container));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_TerrainData", TerrainData.ExportYAML(container));
node.Add("m_TreeDistance", TreeDistance);
node.Add("m_TreeBillboardDistance", TreeBillboardDistance);
node.Add("m_TreeCrossFadeLength", TreeCrossFadeLength);
node.Add("m_TreeMaximumFullLODCount", TreeMaximumFullLODCount);
node.Add("m_DetailObjectDistance", DetailObjectDistance);
node.Add("m_DetailObjectDensity", DetailObjectDensity);
node.Add("m_HeightmapPixelError", HeightmapPixelError);
node.Add("m_SplatMapDistance", SplatMapDistance);
node.Add("m_HeightmapMaximumLOD", HeightmapMaximumLOD);
node.Add("m_CastShadows", CastShadows);
node.Add("m_DrawHeightmap", DrawHeightmap);
node.Add("m_DrawTreesAndFoliage", DrawTreesAndFoliage);
node.Add("m_ReflectionProbeUsage", ReflectionProbeUsage);
node.Add("m_MaterialType", MaterialType);
node.Add("m_LegacySpecular", LegacySpecular.ExportYAML(container));
node.Add("m_LegacyShininess", LegacyShininess);
node.Add("m_MaterialTemplate", MaterialTemplate.ExportYAML(container));
node.Add("m_BakeLightProbesForTrees", BakeLightProbesForTrees);
#warning TODO: get lightmap by index and fill those values
node.Add("m_ScaleInLightmap", 0.0512f);
node.Add("m_LightmapParameters", default(PPtr <Object>).ExportYAML(container));
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(HumanName, Human.ExportYAML(container));
node.Add(SkeletonName, Skeleton.ExportYAML(container));
node.Add(ArmTwistName, ArmTwist);
node.Add(ForeArmTwistName, ForeArmTwist);
node.Add(UpperLegTwistName, UpperLegTwist);
node.Add(LegTwistName, LegTwist);
node.Add(ArmStretchName, ArmStretch);
node.Add(LegStretchName, LegStretch);
node.Add(FeetSpacingName, FeetSpacing);
node.Add(GlobalScaleName, GlobalScale);
node.Add(RootMotionBoneNameName, RootMotionBoneName);
node.Add(HasTranslationDoFName, HasTranslationDoF);
node.Add(HasExtraRootName, HasExtraRoot);
node.Add(SkeletonHasParentsName, SkeletonHasParents);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(GravityName, Gravity.ExportYAML(container));
node.Add(DefaultMaterialName, DefaultMaterial.ExportYAML(container));
node.Add(BounceThresholdName, BounceThreshold);
node.Add(SleepThresholdName, GetSleepThreshold(container.Version));
node.Add(DefaultContactOffsetName, GetDefaultContactOffset(container.Version));
node.Add(DefaultSolverIterationsName, DefaultSolverIterations);
node.Add(DefaultSolverVelocityIterationsName, GetDefaultSolverVelocityIterations(container.Version));
node.Add(QueriesHitBackfacesName, QueriesHitBackfaces);
node.Add(QueriesHitTriggersName, GetQueriesHitTriggers(container.Version));
node.Add(EnableAdaptiveForceName, EnableAdaptiveForce);
node.Add(ClothInterCollisionDistanceName, ClothInterCollisionDistance);
node.Add(ClothInterCollisionStiffnessName, ClothInterCollisionStiffness);
node.Add(ContactsGenerationName, (int)GetContactsGeneration(container.Version));
node.Add(LayerCollisionMatrixName, GetLayerCollisionMatrix(container.Version).ExportYAML(true));
node.Add(AutoSimulationName, GetAutoSimulation(container.Version));
node.Add(AutoSyncTransformsName, GetAutoSyncTransforms(container.Version));
node.Add(ReuseCollisionCallbacksName, ReuseCollisionCallbacks);
node.Add(ClothInterCollisionSettingsToggleName, ClothInterCollisionSettingsToggle);
if (HasClothGravity(container.ExportVersion))
{
node.Add(ClothGravityName, GetClothGravity(container.Version).ExportYAML(container));
}
node.Add(ContactPairsModeName, (int)ContactPairsMode);
node.Add(BroadphaseTypeName, (int)BroadphaseType);
node.Add(WorldBoundsName, GetWorldBounds(container.Version).ExportYAML(container));
node.Add(WorldSubdivisionsName, GetWorldSubdivisions(container.Version));
if (HasFrictionType(container.ExportVersion))
{
node.Add(FrictionTypeName, (int)FrictionType);
node.Add(EnableEnhancedDeterminismName, EnableEnhancedDeterminism);
node.Add(EnableUnifiedHeightmapsName, GetEnableUnifiedHeightmaps(container.Version));
}
if (HasDefaultMaxAngularSpeed(container.ExportVersion))
{
node.Add(ToSerializedVersion(container.ExportVersion) < 13 ? DefaultMaxAngluarSpeedName : DefaultMaxAngularSpeedName,
GetDefaultMaxAngularSpeed(container.Version));
}
return(node);
}
protected sealed override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add(WidthName, Width);
node.Add(HeightName, Height);
node.Add(DepthName, Depth);
node.Add(FormatName, (int)Format);
node.Add(MipCountName, MipCount);
node.Add(DataSizeName, DataSize);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(IsReadableName, IsReadable);
IReadOnlyList <byte> imageData = GetImageData(container.Version);
node.Add(ImageDataName, imageData.Count);
node.Add(TypelessdataName, imageData.ExportYAML());
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(TextName, Text);
node.Add(OffsetZName, OffsetZ);
node.Add(CharacterSizeName, CharacterSize);
node.Add(LineSpacingName, LineSpacing);
node.Add(AnchorName, (short)Anchor);
node.Add(AlignmentName, (short)Alignment);
node.Add(TabSizeName, TabSize);
if (IsReadFontSize(container.ExportVersion))
{
node.Add(FontSizeName, FontSize);
node.Add(FontStyleName, (int)FontStyle);
}
if (IsReadRichText(container.ExportVersion))
{
node.Add(RichTextName, GetRichText(container.Version));
}
node.Add(FontName, Font.ExportYAML(container));
if (IsReadColor(container.ExportVersion))
{
node.Add(ColorName, GetColor(container.Version).ExportYAML(container));
}
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
#warning TODO: serialized version acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_Type", (int)Type);
node.Add("m_Color", Color.ExportYAML(container));
node.Add("m_Intensity", Intensity);
node.Add("m_Range", Range);
node.Add("m_SpotAngle", SpotAngle);
node.Add("m_CookieSize", CookieSize);
node.Add("m_Shadows", Shadows.ExportYAML(container));
node.Add("m_Cookie", Cookie.ExportYAML(container));
node.Add("m_DrawHalo", DrawHalo);
node.Add("m_Flare", Flare.ExportYAML(container));
node.Add("m_RenderMode", (int)RenderMode);
node.Add("m_CullingMask", CullingMask.ExportYAML(container));
node.Add("m_Lightmapping", (int)Lightmapping);
node.Add("m_AreaSize", AreaSize.ExportYAML(container));
node.Add("m_BounceIntensity", BounceIntensity);
node.Add("m_ColorTemperature", ColorTemperature);
node.Add("m_UseColorTemperature", UseColorTemperature);
#warning ???
node.Add("m_ShadowRadius", 0);
node.Add("m_ShadowAngle", 0);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.InsertSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_ChildStates", ChildStates.ExportYAML(container));
node.Add("m_ChildStateMachines", ChildStateMachines.ExportYAML(container));
node.Add("m_AnyStateTransitions", AnyStateTransitions.ExportYAML(container));
node.Add("m_EntryTransitions", EntryTransitions.ExportYAML(container));
node.Add("m_StateMachineTransitions", StateMachineTransitions.ExportYAMLArrayPPtr(container));
node.Add("m_StateMachineBehaviours", StateMachineBehaviours.ExportYAML(container));
node.Add("m_AnyStatePosition", AnyStatePosition.ExportYAML(container));
node.Add("m_EntryPosition", EntryPosition.ExportYAML(container));
node.Add("m_ExitPosition", ExitPosition.ExportYAML(container));
node.Add("m_ParentStateMachinePosition", ParentStateMachinePosition.ExportYAML(container));
node.Add("m_DefaultState", DefaultState.ExportYAML(container));
return(node);
}
protected override void ExportYAMLInner(IExportContainer container, YAMLMappingNode node)
{
node.Add("mainObjectFileID", container.GetExportID(m_mainObject));
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(CodeName, Code);
node.Add(AssetPathName, AssetPath);
node.Add(PlatformMaskName, PlatformMask);
node.Add(HardwareTierVariantsMaskName, HardwareTierVariantsMask);
node.Add(StartLineName, StartLine);
node.Add(TypesMaskName, TypesMask);
node.Add(IncludesHashName, IncludesHash.ExportYAML(container));
node.Add(CodeHashName, CodeHash.ExportYAML(container));
node.Add(FromOtherName, FromOther);
if (HasForceSyncCompilation(container.ExportVersion))
{
node.Add(ForceSyncCompilationName, ForceSyncCompilation);
}
node.Add(LanguageName, Language);
node.Add(VariantsUser0Name, GetVariantsUser0(container.Version).ExportYAML());
node.Add(VariantsUser1Name, GetVariantsUser1(container.Version).ExportYAML());
node.Add(VariantsUser2Name, GetVariantsUser2(container.Version).ExportYAML());
node.Add(VariantsUser3Name, GetVariantsUser3(container.Version).ExportYAML());
node.Add(VariantsUser4Name, GetVariantsUser4(container.Version).ExportYAML());
node.Add(VariantsUser5Name, GetVariantsUser5(container.Version).ExportYAML());
node.Add(VariantsBuiltin0Name, GetVariantsBuiltin0(container.Version).ExportYAML());
node.Add(VariantsBuiltin1Name, GetVariantsBuiltin1(container.Version).ExportYAML());
node.Add(VariantsBuiltin2Name, GetVariantsBuiltin2(container.Version).ExportYAML());
node.Add(VariantsBuiltin3Name, GetVariantsBuiltin3(container.Version).ExportYAML());
node.Add(VariantsBuiltin4Name, GetVariantsBuiltin4(container.Version).ExportYAML());
node.Add(VariantsBuiltin5Name, GetVariantsBuiltin5(container.Version).ExportYAML());
node.Add(BaseRequirementsName, GetBaseRequirements(container.Version));
node.Add(KeywordTargetInfoName, GetKeywordTargetInfo(container.Version).ExportYAML(container));
node.Add(NonStrippedUserKeywordsName, GetNonStrippedUserKeywords(container.Version));
node.Add(BuiltinKeywordsName, GetBuiltinKeywords(container.Version));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
if (HasLODData(container.ExportVersion))
{
node.Add(LODDataName, LODData.ExportYAML(container));
}
else
{
if (HasUse16bitIndices(container.ExportVersion))
{
node.Add(Use16BitIndicesName, Use16BitIndices);
}
if (IsIndexBufferFirst(container.ExportVersion))
{
node.Add(IndexBufferName, IndexBuffer.ExportYAML());
}
node.Add(SubMeshesName, SubMeshes.ExportYAML(container));
}
if (HasBlendShapes(container.ExportVersion))
{
if (HasBlendChannels(container.ExportVersion))
{
node.Add(ShapesName, Shapes.ExportYAML(container));
}
else
{
node.Add(ShapesName, BlendShapes.ExportYAML(container));
node.Add(ShapeVerticesName, ShapeVertices.ExportYAML(container));
}
}
if (HasBindPose(container.ExportVersion))
{
if (IsBindPoseFirst(container.ExportVersion))
{
node.Add(BindPoseName, BindPose.ExportYAML(container));
}
}
if (HasBoneNameHashes(container.ExportVersion))
{
node.Add(BoneNameHashesName, BoneNameHashes.ExportYAML(true));
node.Add(RootBoneNameHashName, RootBoneNameHash);
}
if (HasBonesAABB(container.ExportVersion))
{
node.Add(BonesAABBName, BonesAABB.ExportYAML(container));
node.Add(VariableBoneCountWeightsName, VariableBoneCountWeights.ExportYAML(container));
}
if (HasMeshCompression(container.ExportVersion))
{
node.Add(MeshCompressionName, (byte)MeshCompression);
}
if (HasStreamCompression(container.ExportVersion))
{
node.Add(StreamCompressionName, StreamCompression);
}
if (HasIsReadable(container.ExportVersion))
{
node.Add(IsReadableName, IsReadable);
node.Add(KeepVerticesName, KeepVertices);
node.Add(KeepIndicesName, KeepIndices);
}
if (HasIndexFormat(container.ExportVersion))
{
node.Add(IndexFormatName, (int)IndexFormat);
}
if (!HasLODData(container.ExportVersion))
{
if (!IsIndexBufferFirst(container.ExportVersion))
{
node.Add(IndexBufferName, IndexBuffer.ExportYAML());
}
}
if (HasVertexData(container.ExportVersion))
{
if (!IsOnlyVertexData(container.ExportVersion))
{
if (MeshCompression != MeshCompression.Off)
{
node.Add(VerticesName, Vertices.ExportYAML(container));
}
}
}
else
{
node.Add(VerticesName, Vertices.ExportYAML(container));
}
if (HasSkin(container.ExportVersion))
{
node.Add(SkinName, Skin.ExportYAML(container));
}
if (HasBindPose(container.ExportVersion))
{
if (!IsBindPoseFirst(container.ExportVersion))
{
node.Add(BindPoseName, BindPose.ExportYAML(container));
}
}
if (HasVertexData(container.ExportVersion))
{
if (IsOnlyVertexData(container.ExportVersion))
{
node.Add(VertexDataName, VertexData.ExportYAML(container));
}
else
{
if (MeshCompression == MeshCompression.Off)
{
node.Add(VertexDataName, VertexData.ExportYAML(container));
}
else
{
node.Add(UVName, UV.ExportYAML(container));
node.Add(UV1Name, UV1.ExportYAML(container));
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(NormalsName, Normals.ExportYAML(container));
node.Add(ColorsName, Colors.ExportYAML(container));
}
}
}
else
{
node.Add(UVName, UV.ExportYAML(container));
if (HasUV1(container.ExportVersion))
{
node.Add(UV1Name, UV1.ExportYAML(container));
}
if (HasTangentSpace(container.ExportVersion))
{
node.Add(TangentSpaceName, Tangents.ExportYAML(container));
}
else
{
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(NormalsName, Normals.ExportYAML(container));
}
}
if (HasCompressedMesh(container.ExportVersion))
{
node.Add(CompressedMeshName, CompressedMesh.ExportYAML(container));
}
node.Add(LocalAABBName, LocalAABB.ExportYAML(container));
if (!HasVertexData(container.ExportVersion))
{
node.Add(ColorsName, Colors.ExportYAML(container));
}
if (HasCollisionTriangles(container.ExportVersion))
{
node.Add(CollisionTrianglesName, CollisionTriangles.ExportYAML(true));
node.Add(CollisionVertexCountName, CollisionVertexCount);
}
if (HasMeshUsageFlags(container.ExportVersion))
{
node.Add(MeshUsageFlagsName, MeshUsageFlags);
}
if (HasCollision(container.ExportVersion))
{
node.Add(BakedConvexCollisionMeshName, CollisionData.BakedConvexCollisionMesh.ExportYAML());
node.Add(BakedTriangleCollisionMeshName, CollisionData.BakedTriangleCollisionMesh.ExportYAML());
}
if (HasMeshMetrics(container.ExportVersion))
{
node.Add(MeshMetricsName + "[0]", MeshMetrics[0]);
node.Add(MeshMetricsName + "[1]", MeshMetrics[1]);
}
if (HasMeshOptimization(container.ExportVersion, container.ExportFlags))
{
if (IsMeshOptimizationFlags(container.ExportVersion))
{
node.Add(MeshOptimizationFlagsName, (int)MeshOptimizationFlags);
}
else
{
node.Add(MeshOptimizedName, MeshOptimized);
}
}
if (HasStreamData(container.ExportVersion))
{
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
}
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(BuildTargetName, BuildTarget);
node.Add(MaxTextureSizeName, MaxTextureSize);
if (HasResizeAlgorithm(container.ExportVersion))
{
node.Add(ResizeAlgorithmName, (int)ResizeAlgorithm);
}
node.Add(TextureFormatName, (int)GetTextureFormat(container.Version));
if (HasTextureCompression(container.ExportVersion))
{
node.Add(TextureCompressionName, (int)TextureCompression);
}
if (HasCompressionQuality(container.ExportVersion))
{
node.Add(CompressionQualityName, GetCompressionQuality(container));
}
if (HasCrunchedCompression(container.ExportVersion))
{
node.Add(CrunchedCompressionName, CrunchedCompression);
}
if (HasAllowsAlphaSplitting(container.ExportVersion))
{
node.Add(AllowsAlphaSplittingName, AllowsAlphaSplitting);
}
if (HasOverridden(container.ExportVersion))
{
node.Add(OverriddenName, Overridden);
}
if (HasAndroidETC2FallbackOverride(container.ExportVersion))
{
node.Add(AndroidETC2FallbackOverrideName, (int)AndroidETC2FallbackOverride);
}
if (HasForceMaximumCompressionQuality_BC6H_BC7(container.ExportVersion))
{
node.Add(ForceMaximumCompressionQuality_BC6H_BC7Name, GetForceMaximumCompressionQuality_BC6H_BC7(container.Version));
}
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_Name", Name);
node.Add("descriptiveName", DescriptiveName);
node.Add("descriptiveNegativeName", DescriptiveNegativeName);
node.Add("negativeButton", NegativeButton);
node.Add("positiveButton", PositiveButton);
node.Add("altNegativeButton", AltNegativeButton);
node.Add("altPositiveButton", AltPositiveButton);
node.Add("gravity", Gravity);
node.Add("dead", Dead);
node.Add("sensitivity", Sensitivity);
node.Add("snap", Snap);
node.Add("invert", Invert);
node.Add("type", (int)Type);
node.Add("axis", (int)Axis);
node.Add("joyNum", (int)JoyNum);
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.Add("e00", E00);
node.Add("e01", E01);
node.Add("e02", E02);
node.Add("e03", E03);
node.Add("e10", E10);
node.Add("e11", E11);
node.Add("e12", E12);
node.Add("e13", E13);
node.Add("e20", E20);
node.Add("e21", E21);
node.Add("e22", E22);
node.Add("e23", E23);
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.Add(ShapeName, (int)Shape);
node.Add(StartRangeName, StartRange);
node.Add(EndRangeName, EndRange);
node.Add(LengthName, Length);
node.Add(GravityFocusName, GravityFocus);
node.Add(RotationRandomnessName, RotationRandomness.ExportYAML(container));
node.Add(DirectionCurveXName, DirectionCurveX.ExportYAML(container));
node.Add(DirectionCurveYName, DirectionCurveY.ExportYAML(container));
node.Add(DirectionCurveZName, DirectionCurveZ.ExportYAML(container));
node.Add(GravityCurveName, GravityCurve.ExportYAML(container));
node.Add(RotationSpeedCurveName, RotationSpeedCurve.ExportYAML(container));
node.Add(RotationAttractionCurveName, RotationAttractionCurve.ExportYAML(container));
node.Add(DragCurveName, DragCurve.ExportYAML(container));
node.Add(VectorFieldName, VectorField.ExportYAML(container));
node.Add(VectorFieldSpeedCurveName, VectorFieldSpeedCurve.ExportYAML(container));
node.Add(VectorFieldAttractionCurveName, VectorFieldAttractionCurve.ExportYAML(container));
node.Add(MultiplyDragByParticleSizeName, MultiplyDragByParticleSize);
node.Add(MultiplyDragByParticleVelocityName, MultiplyDragByParticleVelocity);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
#warning TODO: serialized version acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("OutputAudioMixerGroup", OutputAudioMixerGroup.ExportYAML(container));
node.Add("m_audioClip", AudioClip.ExportYAML(container));
node.Add("m_PlayOnAwake", PlayOnAwake);
node.Add("m_Volume", Volume);
node.Add("m_Pitch", Pitch);
node.Add("Loop", Loop);
node.Add("Mute", Mute);
node.Add("Spatialize", Spatialize);
node.Add("SpatializePostEffects", SpatializePostEffects);
node.Add("Priority", Priority);
node.Add("DopplerLevel", DopplerLevel);
node.Add("MinDistance", MinDistance);
node.Add("MaxDistance", MaxDistance);
node.Add("Pan2D", Pan2D);
node.Add("rolloffMode", (int)RolloffMode);
node.Add("BypassEffects", BypassEffects);
node.Add("BypassListenerEffects", BypassListenerEffects);
node.Add("BypassReverbZones", BypassReverbZones);
node.Add("rolloffCustomCurve", GetRolloffCustomCurve(container.Version).ExportYAML(container));
node.Add("panLevelCustomCurve", GetPanLevelCustomCurve(container.Version).ExportYAML(container));
node.Add("spreadCustomCurve", GetSpreadCustomCurve(container.Version).ExportYAML(container));
node.Add("reverbZoneMixCustomCurve", GetReverbZoneMixCustomCurve(container.Version).ExportYAML(container));
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.Add(VerticesName, Vertices.ExportYAML(container));
node.Add(UVName, UV.ExportYAML(container));
if (HasBindPoses(container.ExportVersion))
{
node.Add(BindPosesName, BindPoses.ExportYAML(container));
}
node.Add(NormalsName, Normals.ExportYAML(container));
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(WeightsName, Weights.ExportYAML(container));
node.Add(NormalSignsName, NormalSigns.ExportYAML(container));
node.Add(TangentSignsName, TangentSigns.ExportYAML(container));
if (HasFloatColors(container.ExportVersion))
{
node.Add(FloatColorsName, FloatColors.ExportYAML(container));
}
node.Add(BoneIndicesName, BoneIndices.ExportYAML(container));
node.Add(TrianglesName, Triangles.ExportYAML(container));
if (HasColors(container.ExportVersion))
{
node.Add(ColorsName, Colors.ExportYAML(container));
}
if (HasUVInfo(container.ExportVersion))
{
node.Add(UVInfoName, UVInfo);
}
return(node);
}
public YAMLNode ExportYAML(IExportContainer container)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = new YAMLMappingNode();
node.Add("sh[ 0]", Sh0);
node.Add("sh[ 1]", Sh1);
node.Add("sh[ 2]", Sh2);
node.Add("sh[ 3]", Sh3);
node.Add("sh[ 4]", Sh4);
node.Add("sh[ 5]", Sh5);
node.Add("sh[ 6]", Sh6);
node.Add("sh[ 7]", Sh7);
node.Add("sh[ 8]", Sh8);
node.Add("sh[ 9]", Sh9);
node.Add("sh[10]", Sh10);
node.Add("sh[11]", Sh11);
node.Add("sh[12]", Sh12);
node.Add("sh[13]", Sh13);
node.Add("sh[14]", Sh14);
node.Add("sh[15]", Sh15);
node.Add("sh[16]", Sh16);
node.Add("sh[17]", Sh17);
node.Add("sh[18]", Sh18);
node.Add("sh[19]", Sh19);
node.Add("sh[20]", Sh20);
node.Add("sh[21]", Sh21);
node.Add("sh[22]", Sh22);
node.Add("sh[23]", Sh23);
node.Add("sh[24]", Sh24);
node.Add("sh[25]", Sh25);
node.Add("sh[26]", Sh26);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(LegacyName, GetLegacy(container.Version));
node.Add(CompressedName, Compressed);
node.Add(UseHighQualityCurveName, UseHightQualityCurve);
AnimationCurves curves = GetAnimationCurves(container.Version, container.Flags);
node.Add(RotationCurvesName, curves.RotationCurves.ExportYAML(container));
node.Add(CompressedRotationCurvesName, curves.CompressedRotationCurves.ExportYAML(container));
node.Add(EulerCurvesName, curves.EulerCurves.ExportYAML(container));
node.Add(PositionCurvesName, curves.PositionCurves.ExportYAML(container));
node.Add(ScaleCurvesName, curves.ScaleCurves.ExportYAML(container));
node.Add(FloatCurvesName, curves.FloatCurves.ExportYAML(container));
node.Add(PPtrCurvesName, curves.PPtrCurves.ExportYAML(container));
node.Add(SampleRateName, SampleRate);
node.Add(WrapModeName, (int)WrapMode);
node.Add(BoundsName, Bounds.ExportYAML(container));
node.Add(ClipBindingConstantName, GetClipBindingConstant(container.Version).ExportYAML(container));
node.Add(AnimationClipSettingsName, GetAnimationClipSettings(container.Version, container.Flags).ExportYAML(container));
node.Add(EditorCurvesName, GetEditorCurves(container.Version, container.Flags).ExportYAML(container));
node.Add(EulerEditorCurvesName, GetEulerEditorCurves(container.Version, container.Flags).ExportYAML(container));
node.Add(HasGenericRootTransformName, HasGenericRootTransform);
node.Add(HasMotionFloatCurvesName, HasMotionFloatCurves);
node.Add(GenerateMotionCurvesName, GetGenerateMotionCurves(container.Version, container.Flags));
node.Add(EventsName, GetEvents(container.Version).ExportYAML(container));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add("m_Scene", Scene.ExportYAML(container));
node.Add("m_Lightmaps", Lightmaps.ExportYAML(container));
node.Add("m_LightProbes", LightProbes.ExportYAML(container));
node.Add("m_LightmapsMode", LightmapsMode);
node.Add("m_BakedAmbientProbeInLinear", BakedAmbientProbeInLinear.ExportYAML(container));
node.Add("m_LightmappedRendererData", LightmappedRendererData.ExportYAML(container));
node.Add("m_LightmappedRendererDataIDs", LightmappedRendererDataIDs.ExportYAML(container));
node.Add("m_EnlightenSceneMapping", EnlightenSceneMapping.ExportYAML(container));
node.Add("m_EnlightenSceneMappingRendererIDs", EnlightenSceneMappingRendererIDs.ExportYAML(container));
node.Add("m_Lights", Lights.ExportYAML(container));
node.Add("m_LightBakingOutputs", LightBakingOutputs.ExportYAML(container));
node.Add("m_BakedReflectionProbeCubemaps", BakedReflectionProbeCubemaps.ExportYAML(container));
node.Add("m_BakedReflectionProbes", BakedReflectionProbes.ExportYAML(container));
node.Add("m_EnlightenData", EnlightenData.ExportYAML());
node.Add("m_EnlightenDataVersion", EnlightenDataVersion);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.InsertSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(RenderModeName, (short)RenderMode);
node.Add(SortModeName, (short)SortMode);
node.Add(MinParticleSizeName, MinParticleSize);
node.Add(MaxParticleSizeName, MaxParticleSize);
node.Add(CameraVelocityScaleName, CameraVelocityScale);
node.Add(VelocityScaleName, VelocityScale);
node.Add(LengthScaleName, LengthScale);
node.Add(SortingFudgeName, SortingFudge);
node.Add(NormalDirectionName, GetNormalDirection(container.Version));
node.Add(RenderAlignmentName, (int)RenderAlignment);
node.Add(PivotName, Pivot.ExportYAML(container));
node.Add(UseCustomVertexStreamsName, UseCustomVertexStreams);
node.Add(VertexStreamsName, GetVertexStreams(container.Version).ExportYAML());
node.Add(MeshName, Mesh.ExportYAML(container));
node.Add(Mesh1Name, Mesh1.ExportYAML(container));
node.Add(Mesh2Name, Mesh2.ExportYAML(container));
node.Add(Mesh3Name, Mesh3.ExportYAML(container));
node.Add(MaskInteractionName, (int)MaskInteraction);
return(node);
}
public YAMLNode ExportYAML(IAssetsExporter exporter)
{
#warning TODO: value acording to read version (current 2017.3.0f3)
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(exporter.Version));
node.Add("m_AdditiveReferencePoseClip", default(PPtr <AnimationClip>).ExportYAML(exporter));
node.Add("m_AdditiveReferencePoseTime", 0);
node.Add("m_StartTime", StartTime);
node.Add("m_StopTime", StopTime);
node.Add("m_OrientationOffsetY", OrientationOffsetY);
node.Add("m_Level", Level);
node.Add("m_CycleOffset", CycleOffset);
node.Add("m_HasAdditiveReferencePose", false);
node.Add("m_LoopTime", LoopTime);
node.Add("m_LoopBlend", LoopBlend);
node.Add("m_LoopBlendOrientation", LoopBlendOrientation);
node.Add("m_LoopBlendPositionY", LoopBlendPositionY);
node.Add("m_LoopBlendPositionXZ", LoopBlendPositionXZ);
node.Add("m_KeepOriginalOrientation", KeepOriginalOrientation);
node.Add("m_KeepOriginalPositionY", KeepOriginalPositionY);
node.Add("m_KeepOriginalPositionXZ", KeepOriginalPositionXZ);
node.Add("m_HeightFromFeet", HeightFromFeet);
node.Add("m_Mirror", 0);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add(EnabledName, Enabled);
node.Add(CastShadowsName, (byte)CastShadows);
node.Add(CastShadowsName, ReceiveShadows);
node.Add(DynamicOccludeeName, GetDynamicOccludee(container.Version));
node.Add(MotionVectorsName, (byte)GetMotionVectors(container.Version));
node.Add(LightProbeUsageName, (byte)LightProbeUsage);
node.Add(ReflectionProbeUsageName, (byte)GetReflectionProbeUsage(container.Version));
if (IsReadRenderingLayerMask(container.ExportVersion))
{
node.Add(RenderingLayerMaskName, GetRenderingLayerMask(container.Version));
}
if (IsReadRendererPriority(container.ExportVersion))
{
node.Add(RendererPriorityName, RendererPriority);
}
node.Add(MaterialsName, Materials.ExportYAML(container));
node.Add(StaticBatchInfoName, GetStaticBatchInfo(container.Version).ExportYAML(container));
node.Add(StaticBatchRootName, StaticBatchRoot.ExportYAML(container));
node.Add(ProbeAnchorName, ProbeAnchor.ExportYAML(container));
node.Add(LightProbeVolumeOverrideName, LightProbeVolumeOverride.ExportYAML(container));
node.Add(ScaleInLightmapName, GetScaleInLightmap(container.Version, container.Flags));
if (IsReadReceiveGI(container.ExportVersion, container.ExportFlags))
{
node.Add(ReceiveGIName, (int)GetReceiveGI(container.Version, container.Flags));
}
node.Add(PreserveUVsName, GetPreserveUVs(container.Version, container.Flags));
node.Add(IgnoreNormalsForChartDetectionName, GetIgnoreNormalsForChartDetection(container.Version, container.Flags));
node.Add(ImportantGIName, GetImportantGI(container.Version, container.Flags));
node.Add(StitchLightmapSeamsName, GetStitchLightmapSeams(container.Version, container.Flags));
node.Add(SelectedEditorRenderStateName, (int)GetSelectedEditorRenderState(container.Version, container.Flags));
node.Add(MinimumChartSizeName, GetMinimumChartSize(container.Version, container.Flags));
node.Add(AutoUVMaxDistanceName, GetAutoUVMaxDistance(container.Version, container.Flags));
node.Add(AutoUVMaxAngleName, GetAutoUVMaxAngle(container.Version, container.Flags));
node.Add(LightmapParametersName, GetLightmapParameters().ExportYAML(container));
node.Add(SortingLayerIDName, SortingLayerID);
node.Add(SortingLayerName, SortingLayer);
node.Add(SortingOrderName, SortingOrder);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(DeferredName, ExportDeferred(container));
node.Add(DeferredReflectionsName, ExportDeferredReflections(container));
node.Add(ScreenSpaceShadowsName, ExportScreenSpaceShadows(container));
node.Add(LegacyDeferredName, ExportLegacyDeferred(container));
node.Add(DepthNormalsName, ExportDepthNormals(container));
node.Add(MotionVectorsName, ExportMotionVectors(container));
node.Add(LightHaloName, ExportLightHalo(container));
node.Add(LensFlareName, ExportLensFlare(container));
node.Add(AlwaysIncludedShadersName, ExportAlwaysIncludedShaders(container));
node.Add(PreloadedShadersName, GetPreloadedShaders(container.Version).ExportYAML(container));
node.Add(SpritesDefaultMaterialName, GetSpritesDefaultMaterial(container.Version).ExportYAML(container));
node.Add(CustomRenderPipelineName, CustomRenderPipeline.ExportYAML(container));
node.Add(TransparencySortModeName, (int)TransparencySortMode);
node.Add(TransparencySortAxisName, GetTransparencySortAxis(container.Version).ExportYAML(container));
node.Add(DefaultRenderingPathName, (int)GetDefaultRenderingPath(container.Version, container.Flags));
node.Add(DefaultMobileRenderingPathName, (int)GetDefaultMobileRenderingPath(container.Version, container.Flags));
node.Add(TierSettingsName, GetTierSettings(container.Version, container.Platform, container.Flags).ExportYAML(container));
node.Add(LightmapStrippingName, (int)GetLightmapStripping(container.Flags));
node.Add(FogStrippingName, (int)GetFogStripping(container.Flags));
node.Add(InstancingStrippingName, (int)GetInstancingStripping(container.Flags));
node.Add(LightmapKeepPlainName, GetLightmapKeepPlain(container.Version, container.Flags));
node.Add(LightmapKeepDirCombinedName, GetLightmapKeepDirCombined(container.Version, container.Flags));
node.Add(LightmapKeepDynamicPlainName, GetLightmapKeepDynamicPlain(container.Version, container.Flags));
node.Add(LightmapKeepDynamicDirCombinedName, GetLightmapKeepDynamicDirCombined(container.Version, container.Flags));
node.Add(LightmapKeepShadowMaskName, GetLightmapKeepShadowMask(container.Version, container.Flags));
node.Add(LightmapKeepSubtractiveName, GetLightmapKeepSubtractive(container.Version, container.Flags));
node.Add(FogKeepLinearName, GetFogKeepLinear(container.Version, container.Flags));
node.Add(FogKeepExpName, GetFogKeepExp(container.Version, container.Flags));
node.Add(FogKeepExp2Name, GetFogKeepExp2(container.Version, container.Flags));
node.Add(AlbedoSwatchInfosName, GetAlbedoSwatchInfos(container.Version, container.Flags).ExportYAML(container));
node.Add(LightsUseLinearIntensityName, LightsUseLinearIntensity);
node.Add(LightsUseColorTemperatureName, LightsUseColorTemperature);
if (HasLogWhenShaderIsCompiled(container.ExportVersion))
{
node.Add(LogWhenShaderIsCompiledName, LogWhenShaderIsCompiled);
}
if (HasAllowEnlightenSupportForUpgradedProject(container.ExportVersion))
{
node.Add(AllowEnlightenSupportForUpgradedProjectName, GetAllowEnlightenSupportForUpgradedProject(container.Version));
}
return(node);
}