private void GenerateTexture(string assetPath)
{
SourceTextureInformation textureInformation = new SourceTextureInformation()
{
containsAlpha = true,
hdr = false,
height = textureHeight,
width = textureWidth
};
TextureImporterPlatformSettings platformSettings = new TextureImporterPlatformSettings()
{
overridden = false
};
TextureGenerationSettings settings = new TextureGenerationSettings()
{
assetPath = assetPath,
spriteImportData = ConvertAseFileSpriteImportDataToUnity(SpriteImportData),
textureImporterSettings = TextureImportSettings.ToImporterSettings(),
enablePostProcessor = false,
sourceTextureInformation = textureInformation,
qualifyForSpritePacking = true,
platformSettings = platformSettings,
spritePackingTag = "aseprite",
secondarySpriteTextures = new SecondarySpriteTexture[0]
};
TextureGenerationOutput output = TextureGenerator.GenerateTexture(settings, new Unity.Collections.NativeArray <Color32>(atlas.GetPixels32(), Unity.Collections.Allocator.Temp));
Texture = output.texture;
thumbnail = output.thumbNail;
sprites = output.sprites;
}
private static UnityTexture2D GetTextureToSlice(string path)
{
TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
MethodInfo method = ti.GetType().GetMethod("GetSourceTextureInformation", BindingFlags.Instance | BindingFlags.NonPublic);
var val = method.Invoke(ti, null);
SourceTextureInformation info = val as SourceTextureInformation;
int width = info.width;
int height = info.height;
UnityTexture2D tex = AssetDatabase.LoadAssetAtPath <UnityTexture2D>(path);
// we want to slice based on the original texture slice. Upscale the imported texture
var texture = CreateTemporaryDuplicate(tex, width, height);
if (texture != null)
{
texture.filterMode = tex.filterMode;
}
return(texture);
}
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);
}
