public List <GameObject> UpdateOutlines()
{
List <List <Vector3> > linesPoints = SpriteBorder.Generate(gameObject, lineOffset);
List <GameObject> createdLines = new List <GameObject>();
int lineIdx = 0;
int linesBeforeCreating = linesToUpdate.Count;
foreach (var linePoints in linesPoints)
{
foreach (var part in lineParts)
{
LineRenderer line;
if (lineIdx < linesBeforeCreating)
{
line = linesToUpdate[lineIdx];
lineIdx++;
}
else
{
if (part.overrideGameObject != null)
{
line = Instantiate(prefabWithLineRenderer, transform.position, transform.rotation, transform).GetComponent <LineRenderer>();
}
else
{
line = Instantiate(prefabWithLineRenderer, transform.position, transform.rotation, transform).GetComponent <LineRenderer>();
}
linesToUpdate.Add(line);
}
createdLines.Add(line.gameObject);
int startToRemove = (int)(linePoints.Count * part.LineStartNormalized);
int endtoRemoveStartId = (int)(linePoints.Count * (part.LineEndNormalized));
int endToRemove = linePoints.Count - endtoRemoveStartId;
List <Vector3> lineCut = new List <Vector3>(linePoints);
if (part.LineStartNormalized != 0)
{
lineCut.RemoveRange(0, startToRemove);
}
if (part.LineEndNormalized != 1)
{
lineCut.RemoveRange(endtoRemoveStartId - startToRemove, endToRemove);
}
line.positionCount = lineCut.Count;
line.SetPositions(lineCut.ToArray());
}
}
return(createdLines);
}
void GenerateShapesBasedOnMesh()
{
var selected = Selection.gameObjects;
foreach (var gameObject in selected)
{
string path = AssetDatabase.GetAssetPath(gameObject);
SVGImporter importer = AssetImporter.GetAtPath(path) as SVGImporter;
if (importer != null)
{
var sprite = (Sprite)importer.targetObject;
var outlines = SpriteBorder.Generate(gameObject, Vector3.zero);
Rect rect = sprite.rect;
Bounds bounds = sprite.bounds;
List <Vector2[]> newOutlines = new List <Vector2[]>(outlines.Count);
foreach (var outline in outlines)
{
List <Vector2> converterOutline = new List <Vector2>(outline.Count);
foreach (var v in outline)
{
converterOutline.Add(new Vector2(v.x * (rect.width / bounds.size.x), v.y * (rect.height / bounds.size.y)));
}
newOutlines.Add(converterOutline.ToArray());
}
OverwriteOutline(sprite, 0, newOutlines);
Debug.Log(outlines.Count + " -> outlines.Count");
//Vector2 outlines
//Selection.activeObject = sprite;
//spriteWindow = Type.GetType("UnityEditor.SpriteEditorWindow, UnityEditor", true);
//var getWindowMethod = spriteWindow.GetMethod("GetWindow", BindingFlags.Public | BindingFlags.Static);
//getWindowMethod.Invoke(null, null);
////if (spriteWindowInstance == null)
//spriteWindowInstance = spriteWindow.GetField("s_Instance").GetValue(null);
//SpriteWindowMethod("OnSelectionChange");
////string selecionPath = SpriteWindowMethod("GetSelectionAssetPath") as string;
////Choose custom outline mode
//SpriteWindowMethod("SetupModule", (object)1);
//Type spritePhysicsShapeModule = Type.GetType("UnityEditor.U2D.SpritePhysicsShapeModule, UnityEditor", true);
//object outlineWindowInstance = SpriteWindowField("m_CurrentModule");
//Type spriteOutlineModule = spritePhysicsShapeModule.BaseType;
////Method(Type.GetType("UnityEditor.Experimental.U2D.SpriteEditorModuleBase, UnityEditor", true), outlineWindowInstance, "OnModuleActivate", null);
//object m_Outline = Field(spriteOutlineModule, outlineWindowInstance, "m_Outline");
//Type spriteOutlineModel = Type.GetType("UnityEditor.U2D.SpriteOutlineModel, UnityEditor", true);
//object m_SpriteOutlineList = spriteOutlineModel.InvokeMember("", BindingFlags.GetProperty, null, m_Outline, new object[] { 0 });
//Type SpriteOutlineList = Type.GetType("UnityEditor.U2D.SpriteOutlineList, UnityEditor", true);
//SpriteOutlineList.GetField("m_TessellationDetail", bf).SetValue(m_SpriteOutlineList, 0.3f);
////3. this.SetupShapeEditorOutline(this.m_Selected);
//SpriteRect m_Selected = spriteOutlineModule.GetField("m_Selected", bf).GetValue(outlineWindowInstance) as SpriteRect;
//Method(spriteOutlineModule, outlineWindowInstance, "SetupShapeEditorOutline", m_Selected);
//List<Vector2[]> outlines = new List<Vector2[]>((List<Vector2[]>)Method(SpriteOutlineList, m_SpriteOutlineList, "ToListVector"));
//float tessellation = (float)SpriteOutlineList.GetField("m_TessellationDetail", bf).GetValue(m_SpriteOutlineList);
//Method(Type.GetType("UnityEditor.Experimental.U2D.SpriteEditorModuleBase, UnityEditor", true), outlineWindowInstance, "ApplyRevert", true);
////Method(Type.GetType("UnityEditor.Experimental.U2D.SpriteEditorModuleBase, UnityEditor", true), outlineWindowInstance, "OnModuleDeactivate", null);
//object ISpriteEditor = spritePhysicsShapeModule.GetProperty("spriteEditorWindow", bf).GetValue(outlineWindowInstance);
//Method(Type.GetType("UnityEditor.Experimental.U2D.ISpriteEditor, UnityEditor", true), ISpriteEditor, "ApplyOrRevertModification", true);
////Method(Type.GetType("UnityEditor.Experimental.U2D.ISpriteEditor, UnityEditor", true), ISpriteEditor, "SetDataModified");
////spriteOutlineModule.GetField("shapeEditorDirty").SetValue(outlineWindowInstance, true);
//Debug.Log(outlines[0].Length + " count");
//AssetDatabase.Refresh();
//EditorUtility.SetDirty(sprite);
//AssetDatabase.SaveAssets();
//OverwriteOutline(sprite, tessellation, outlines);
}
}
}
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);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
bool isBoolFlags = IsBoolFlags(writer.Version);
writer.Write((int)MipMapMode);
if (isBoolFlags)
{
writer.Write(EnableMipMapBool);
writer.Write(CorrectGammaBool);
writer.Write(FadeOutBool);
writer.Write(BorderMipMapBool);
}
else
{
writer.Write(EnableMipMap);
if (HasSRGBTexture(writer.Version))
{
writer.Write(SRGBTexture);
}
if (HasLinearTexture(writer.Version))
{
writer.Write(LinearTexture);
}
if (HasCorrectGamma(writer.Version))
{
writer.Write(CorrectGamma);
}
writer.Write(FadeOut);
writer.Write(BorderMipMap);
}
if (HasMipMapsPreserveCoverage(writer.Version))
{
writer.Write(MipMapsPreserveCoverage);
writer.Write(AlphaTestReferenceValue);
}
writer.Write(MipMapFadeDistanceStart);
writer.Write(MipMapFadeDistanceEnd);
if (isBoolFlags)
{
writer.Write(ConvertToNormalMapBool);
if (HasIsReadable(writer.Version))
{
writer.Write(IsReadableBool);
}
}
else
{
writer.Write(ConvertToNormalMap);
writer.Write(ExternalNormalMap);
if (IsReadableFirst(writer.Version))
{
writer.Write(IsReadable);
writer.AlignStream();
}
}
writer.Write(HeightScale);
writer.Write((int)NormalMapFilter);
if (!IsReadableFirst(writer.Version))
{
writer.Write(IsReadable);
}
if (HasStreamingMipmaps(writer.Version))
{
writer.Write(StreamingMipmaps);
writer.Write(StreamingMipmapsPriority);
}
if (isBoolFlags)
{
writer.Write(GrayScaleToAlphaBool);
}
else
{
writer.Write(GrayScaleToAlpha);
}
if (IsAlignGrayScaleToAlpha(writer.Version))
{
writer.AlignStream();
}
writer.Write((int)GenerateCubemap);
if (HasCubemapConvolution(writer.Version))
{
writer.Write(CubemapConvolution);
}
if (HasCubemapConvolutionSteps(writer.Version))
{
writer.Write(CubemapConvolutionSteps);
writer.Write(CubemapConvolutionExponent);
}
if (HasSeamlessCubemap(writer.Version))
{
writer.Write(SeamlessCubemap);
}
writer.Write((int)TextureFormat);
if (IsAlignTextureFormat(writer.Version))
{
writer.AlignStream();
}
if (HasRecommendedTextureFormat(writer.Version) && RecommendedTextureFormatFirst(writer.Version))
{
writer.Write(RecommendedTextureFormat);
writer.AlignStream();
}
writer.Write(MaxTextureSize);
TextureSettings.Write(writer);
writer.Write((int)NPOTScale);
if (HasLightmap(writer.Version))
{
writer.Write(Lightmap);
}
if (HasRGBM(writer.Version))
{
writer.Write(RGBM);
}
if (HasCompressionQuality(writer.Version))
{
writer.Write(CompressionQuality);
}
if (HasAllowsAlphaSplitting(writer.Version))
{
writer.Write(AllowsAlphaSplitting);
writer.AlignStream();
}
if (HasSprite(writer.Version))
{
writer.Write((int)SpriteMode);
writer.Write(SpriteExtrude);
writer.Write((int)SpriteMeshType);
writer.Write((int)Alignment);
SpritePivot.Write(writer);
}
if (HasSprite(writer.Version) && SpritePixelsToUnitsFirst(writer.Version))
{
writer.Write(SpritePixelsToUnits);
}
if (HasSpriteBorder(writer.Version))
{
SpriteBorder.Write(writer);
}
if (HasSprite(writer.Version) && !SpritePixelsToUnitsFirst(writer.Version))
{
writer.Write(SpritePixelsToUnits);
}
if (HasSpriteGenerateFallbackPhysicsShape(writer.Version))
{
writer.Write(SpriteGenerateFallbackPhysicsShape);
}
if (HasAlphaUsage(writer.Version))
{
writer.Write((int)AlphaUsage);
}
if (HasAlphaIsTransparency(writer.Version))
{
writer.Write(AlphaIsTransparency);
}
if (HasSpriteTessellationDetail(writer.Version))
{
writer.Write(SpriteTessellationDetail);
}
if (HasTextureType(writer.Version))
{
writer.Write((int)TextureType);
}
if (HasRecommendedTextureFormat(writer.Version) && !RecommendedTextureFormatFirst(writer.Version))
{
writer.Write(RecommendedTextureFormat);
}
if (HasSourceTextureInformation(writer.Version))
{
SourceTextureInformation.Write(writer);
writer.AlignStream();
}
if (HasTextureShape(writer.Version))
{
writer.Write((int)TextureShape);
}
if (HasSingleChannelComponent(writer.Version))
{
writer.Write(SingleChannelComponent);
}
if (HasMaxTextureSizeSet(writer.Version))
{
writer.Write(MaxTextureSizeSet);
writer.Write(CompressionQualitySet);
writer.Write(TextureFormatSet);
}
writer.AlignStream();
if (HasPlatformSettings(writer.Version))
{
PlatformSettings.Write(writer);
}
if (HasSprite(writer.Version))
{
SpriteSheet.Write(writer);
writer.Write(SpritePackingTag);
}
if (HasOutput(writer.Version))
{
Output.Write(writer);
}
if (HasPSDRemoveMatte(writer.Version))
{
writer.Write(PSDRemoveMatte);
writer.Write(PSDShowRemoveMatteOption);
}
writer.AlignStream();
PostWrite(writer);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
bool isBoolFlags = IsBoolFlags(reader.Version);
MipMapMode = (TextureImporterMipFilter)reader.ReadInt32();
if (isBoolFlags)
{
EnableMipMapBool = reader.ReadBoolean();
CorrectGammaBool = reader.ReadBoolean();
FadeOutBool = reader.ReadBoolean();
BorderMipMapBool = reader.ReadBoolean();
}
else
{
EnableMipMap = reader.ReadInt32();
if (HasSRGBTexture(reader.Version))
{
SRGBTexture = reader.ReadInt32();
}
if (HasLinearTexture(reader.Version))
{
LinearTexture = reader.ReadInt32();
}
if (HasCorrectGamma(reader.Version))
{
CorrectGamma = reader.ReadInt32();
}
FadeOut = reader.ReadInt32();
BorderMipMap = reader.ReadInt32();
}
if (HasMipMapsPreserveCoverage(reader.Version))
{
MipMapsPreserveCoverage = reader.ReadInt32();
AlphaTestReferenceValue = reader.ReadSingle();
}
MipMapFadeDistanceStart = reader.ReadInt32();
MipMapFadeDistanceEnd = reader.ReadInt32();
if (isBoolFlags)
{
ConvertToNormalMapBool = reader.ReadBoolean();
if (HasIsReadable(reader.Version))
{
IsReadableBool = reader.ReadBoolean();
}
}
else
{
ConvertToNormalMap = reader.ReadInt32();
ExternalNormalMap = reader.ReadInt32();
if (IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadInt32();
reader.AlignStream();
}
}
HeightScale = reader.ReadSingle();
NormalMapFilter = (TextureImporterNormalFilter)reader.ReadInt32();
if (!IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadInt32();
}
if (HasStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadInt32();
StreamingMipmapsPriority = reader.ReadInt32();
}
if (isBoolFlags)
{
GrayScaleToAlphaBool = reader.ReadBoolean();
}
else
{
GrayScaleToAlpha = reader.ReadInt32();
}
if (IsAlignGrayScaleToAlpha(reader.Version))
{
reader.AlignStream();
}
GenerateCubemap = (TextureImporterGenerateCubemap)reader.ReadInt32();
if (HasCubemapConvolution(reader.Version))
{
CubemapConvolution = reader.ReadInt32();
}
if (HasCubemapConvolutionSteps(reader.Version))
{
CubemapConvolutionSteps = reader.ReadInt32();
CubemapConvolutionExponent = reader.ReadSingle();
}
if (HasSeamlessCubemap(reader.Version))
{
SeamlessCubemap = reader.ReadInt32();
}
TextureFormat = (TextureFormat)reader.ReadInt32();
if (IsAlignTextureFormat(reader.Version))
{
reader.AlignStream();
}
if (HasRecommendedTextureFormat(reader.Version) && RecommendedTextureFormatFirst(reader.Version))
{
RecommendedTextureFormat = reader.ReadInt32();
reader.AlignStream();
}
MaxTextureSize = reader.ReadInt32();
TextureSettings.Read(reader);
NPOTScale = (TextureImporterNPOTScale)reader.ReadInt32();
if (HasLightmap(reader.Version))
{
Lightmap = reader.ReadInt32();
}
if (HasRGBM(reader.Version))
{
RGBM = reader.ReadInt32();
}
if (HasCompressionQuality(reader.Version))
{
CompressionQuality = reader.ReadInt32();
}
if (HasAllowsAlphaSplitting(reader.Version))
{
AllowsAlphaSplitting = reader.ReadInt32();
reader.AlignStream();
}
if (HasSprite(reader.Version))
{
SpriteMode = (SpriteImportMode)reader.ReadInt32();
SpriteExtrude = reader.ReadUInt32();
SpriteMeshType = (SpriteMeshType)reader.ReadInt32();
Alignment = (SpriteAlignment)reader.ReadInt32();
SpritePivot.Read(reader);
}
if (HasSprite(reader.Version) && SpritePixelsToUnitsFirst(reader.Version))
{
SpritePixelsToUnits = reader.ReadSingle();
}
if (HasSpriteBorder(reader.Version))
{
SpriteBorder.Read(reader);
}
if (HasSprite(reader.Version) && !SpritePixelsToUnitsFirst(reader.Version))
{
SpritePixelsToUnits = reader.ReadSingle();
}
if (HasSpriteGenerateFallbackPhysicsShape(reader.Version))
{
SpriteGenerateFallbackPhysicsShape = reader.ReadInt32();
}
if (HasAlphaUsage(reader.Version))
{
AlphaUsage = (TextureImporterAlphaSource)reader.ReadInt32();
}
if (HasAlphaIsTransparency(reader.Version))
{
AlphaIsTransparency = reader.ReadInt32();
}
if (HasSpriteTessellationDetail(reader.Version))
{
SpriteTessellationDetail = reader.ReadSingle();
}
if (HasTextureType(reader.Version))
{
TextureType = (TextureImporterType)reader.ReadInt32();
}
if (HasRecommendedTextureFormat(reader.Version) && !RecommendedTextureFormatFirst(reader.Version))
{
RecommendedTextureFormat = reader.ReadInt32();
}
if (HasSourceTextureInformation(reader.Version))
{
SourceTextureInformation = reader.ReadAsset <SourceTextureInformation>();
reader.AlignStream();
}
if (HasTextureShape(reader.Version))
{
TextureShape = (TextureImporterShape)reader.ReadInt32();
}
if (HasSingleChannelComponent(reader.Version))
{
SingleChannelComponent = reader.ReadInt32();
}
if (HasMaxTextureSizeSet(reader.Version))
{
MaxTextureSizeSet = reader.ReadInt32();
CompressionQualitySet = reader.ReadInt32();
TextureFormatSet = reader.ReadInt32();
}
reader.AlignStream();
if (HasPlatformSettings(reader.Version))
{
PlatformSettings = reader.ReadAssetArray <TextureImporterPlatformSettings>();
}
if (HasSprite(reader.Version))
{
SpriteSheet.Read(reader);
SpritePackingTag = reader.ReadString();
}
if (HasOutput(reader.Version))
{
Output.Read(reader);
}
if (HasPSDRemoveMatte(reader.Version))
{
PSDRemoveMatte = reader.ReadBoolean();
PSDShowRemoveMatteOption = reader.ReadBoolean();
}
reader.AlignStream();
PostRead(reader);
}
