protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
        {
            YAMLMappingNode node = base.ExportYAMLRoot(container);

            node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));

            YAMLMappingNode mipmap = new YAMLMappingNode();

            mipmap.Add(MipMapModeName, (int)MipMapMode);
            mipmap.Add(EnableMipMapName, EnableMipMap);
            if (HasSRGBTexture(container.ExportVersion))
            {
                mipmap.Add(SRGBTextureName, SRGBTexture);
            }
            if (HasLinearTexture(container.ExportVersion))
            {
                mipmap.Add(LinearTextureName, LinearTexture);
            }
            if (HasCorrectGamma(container.ExportVersion))
            {
                mipmap.Add(CorrectGammaName, CorrectGamma);
            }
            mipmap.Add(FadeOutName, FadeOut);
            mipmap.Add(BorderMipMapName, BorderMipMap);
            if (HasMipMapsPreserveCoverage(container.ExportVersion))
            {
                mipmap.Add(MipMapsPreserveCoverageName, MipMapsPreserveCoverage);
                mipmap.Add(AlphaTestReferenceValueName, AlphaTestReferenceValue);
            }
            mipmap.Add(MipMapFadeDistanceStartName, MipMapFadeDistanceStart);
            mipmap.Add(MipMapFadeDistanceEndName, MipMapFadeDistanceEnd);
            node.Add(MipmapsName, mipmap);

            YAMLMappingNode bumpmap = new YAMLMappingNode();

            bumpmap.Add(ConvertToNormalMapName, ConvertToNormalMap);
            if (HasExternalNormalMap(container.ExportVersion))
            {
                bumpmap.Add(ExternalNormalMapName, ExternalNormalMap);
            }
            bumpmap.Add(HeightScaleName, HeightScale);
            bumpmap.Add(NormalMapFilterName, (int)NormalMapFilter);
            node.Add(BumpmapName, bumpmap);

            if (HasIsReadable(container.ExportVersion))
            {
                node.Add(IsReadableName, IsReadable);
            }
            if (HasStreamingMipmaps(container.ExportVersion))
            {
                node.Add(StreamingMipmapsName, StreamingMipmaps);
                node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority);
            }

            node.Add(GrayScaleToAlphaName, GrayScaleToAlpha);
            node.Add(GenerateCubemapName, (int)GenerateCubemap);
            if (HasCubemapConvolution(container.ExportVersion))
            {
                node.Add(CubemapConvolutionName, CubemapConvolution);
            }
            if (HasCubemapConvolutionSteps(container.ExportVersion))
            {
                node.Add(CubemapConvolutionStepsName, CubemapConvolutionSteps);
                node.Add(CubemapConvolutionExponentName, CubemapConvolutionExponent);
            }
            if (HasSeamlessCubemap(container.ExportVersion))
            {
                node.Add(SeamlessCubemapName, SeamlessCubemap);
            }

            node.Add(TextureFormatName, (int)TextureFormat);
            if (HasRecommendedTextureFormat(container.ExportVersion) && RecommendedTextureFormatFirst(container.ExportVersion))
            {
                node.Add(RecommendedTextureFormatName, RecommendedTextureFormat);
            }

            node.Add(MaxTextureSizeName, MaxTextureSize);
            node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
            node.Add(NPOTScaleName, (int)NPOTScale);
            if (HasLightmap(container.ExportVersion))
            {
                node.Add(LightmapName, Lightmap);
            }
            if (HasRGBM(container.ExportVersion))
            {
                node.Add(RGBMName, RGBM);
            }
            if (HasCompressionQuality(container.ExportVersion))
            {
                node.Add(CompressionQualityName, CompressionQuality);
            }
            if (HasAllowsAlphaSplitting(container.ExportVersion))
            {
                node.Add(AllowsAlphaSplittingName, AllowsAlphaSplitting);
            }
            if (HasSprite(container.ExportVersion))
            {
                node.Add(SpriteModeName, (int)SpriteMode);
                node.Add(SpriteExtrudeName, SpriteExtrude);
                node.Add(SpriteMeshTypeName, (int)SpriteMeshType);
                node.Add(AlignmentName, (int)Alignment);
                node.Add(SpritePivotName, SpritePivot.ExportYAML(container));
            }
            if (HasSprite(container.ExportVersion) && SpritePixelsToUnitsFirst(container.ExportVersion))
            {
                node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits);
            }
            if (HasSpriteBorder(container.ExportVersion))
            {
                node.Add(SpriteBorderName, SpriteBorder.ExportYAML(container));
            }
            if (HasSprite(container.ExportVersion) && !SpritePixelsToUnitsFirst(container.ExportVersion))
            {
                node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits);
            }
            if (HasSpriteGenerateFallbackPhysicsShape(container.ExportVersion))
            {
                node.Add(SpriteGenerateFallbackPhysicsShapeName, SpriteGenerateFallbackPhysicsShape);
            }
            if (HasAlphaUsage(container.ExportVersion))
            {
                node.Add(AlphaUsageName, (int)AlphaUsage);
            }
            if (HasAlphaIsTransparency(container.ExportVersion))
            {
                node.Add(AlphaIsTransparencyName, AlphaIsTransparency);
            }
            if (HasSpriteTessellationDetail(container.ExportVersion))
            {
                node.Add(SpriteTessellationDetailName, SpriteTessellationDetail);
            }
            if (HasTextureType(container.ExportVersion))
            {
                node.Add(TextureTypeName, (int)TextureType);
            }
            if (HasRecommendedTextureFormat(container.ExportVersion) && !RecommendedTextureFormatFirst(container.ExportVersion))
            {
                node.Add(RecommendedTextureFormatName, RecommendedTextureFormat);
            }
            if (HasSourceTextureInformation(container.ExportVersion))
            {
                node.Add(SourceTextureInformationName, SourceTextureInformation.ExportYAML(container));
            }
            if (HasTextureShape(container.ExportVersion))
            {
                node.Add(TextureShapeName, (int)TextureShape);
            }
            if (HasSingleChannelComponent(container.ExportVersion))
            {
                node.Add(SingleChannelComponentName, SingleChannelComponent);
            }
            if (HasMaxTextureSizeSet(container.ExportVersion))
            {
                node.Add(MaxTextureSizeSetName, MaxTextureSizeSet);
                node.Add(CompressionQualitySetName, CompressionQualitySet);
                node.Add(TextureFormatSetName, TextureFormatSet);
            }
            if (HasPlatformSettings(container.ExportVersion))
            {
                node.Add(GetPlatformSettingsName(container.ExportVersion), PlatformSettings.ExportYAML(container));
            }
            if (HasSprite(container.ExportVersion))
            {
                node.Add(SpriteSheetName, SpriteSheet.ExportYAML(container));
                node.Add(SpritePackingTagName, SpritePackingTag);
            }

            /*if (HasOutput(container.ExportVersion))
             * {
             *      node.Add(OutputName, Output.ExportYAML(container));
             * }*/
            if (HasPSDRemoveMatte(container.ExportVersion))
            {
                node.Add(PSDRemoveMatteName, PSDRemoveMatte);
                node.Add(PSDShowRemoveMatteOptionName, PSDShowRemoveMatteOption);
            }
            PostExportYAML(container, node);
            return(node);
        }