void RenderRow(IExportContainer container){
if (IsGraphicsContainer(container)) {
RenderGraphicsContainer(container);
} else {
RenderDataRow(container);
}
}
void RenderRow(Canvas canvas, IExportContainer container){
if (IsGraphicsContainer(container)) {
canvas.Children.Add(RenderGraphicsContainer(container));
} else {
canvas.Children.Add(RenderDataRow((ExportContainer)container));
}
}
static Size ArrangeInternal(IExportContainer container)
{
var containerRectangle = container.DisplayRectangle;
Rectangle elementRectangle = Rectangle.Empty;
foreach (var element in container.ExportedItems) {
var con = element as IExportContainer;
if (con != null) {
var keep = containerRectangle;
con.DesiredSize = ArrangeInternal(con);
elementRectangle = AdujstRectangles(keep,con.DisplayRectangle);
containerRectangle = keep;
} else {
elementRectangle = AdujstRectangles(containerRectangle,element.DisplayRectangle);
}
if (!containerRectangle.Contains(elementRectangle)) {
containerRectangle = new Rectangle(containerRectangle.Left,
containerRectangle.Top ,
containerRectangle.Width,
element.Location.Y + elementRectangle.Size.Height + 5);
}
}
return containerRectangle.Size;
}
void ShowDebug(IExportContainer container)
{
foreach (var item in container.ExportedItems) {
var exportContainer = item as IExportContainer;
var acceptor = item as IAcceptor;
if (exportContainer != null) {
if (acceptor != null) {
Console.WriteLine("--container--");
acceptor.Accept(visitor);
}
ShowDebug(item as IExportContainer);
} else {
if (acceptor != null) {
Console.WriteLine("..Item...");
acceptor.Accept(visitor);
}
}
}
}
public static void ShowDebug(IExportContainer exportContainer)
{
var visitor = new DebugVisitor();
foreach (var item in exportContainer.ExportedItems) {
var container = item as IExportContainer;
var acceptor = item as IAcceptor;
if (container != null) {
if (acceptor != null) {
Console.WriteLine("----");
acceptor.Accept(visitor);
}
ShowDebug(container);
} else {
if (acceptor != null) {
acceptor.Accept(visitor);
}
}
}
}
void InternalRun(IExportContainer container)
{
Canvas canvas = null ;
foreach (var item in container.ExportedItems) {
var exportContainer = item as IExportContainer;
var acceptor = item as IAcceptor;
if (exportContainer != null) {
if (acceptor != null) {
acceptor.Accept(visitor);
canvas = (Canvas)visitor.UIElement;
fixedPage.Children.Add(canvas);
foreach (IAcceptor element in exportContainer.ExportedItems) {
element.Accept(visitor);
var ui = visitor.UIElement;
Canvas.SetLeft(ui,((IExportColumn)element).Location.X);
Canvas.SetTop(ui, ((IExportColumn)element).Location.Y);
canvas.Children.Add(ui);
}
// var size = new Size(exportContainer.DesiredSize.Width,exportContainer.DesiredSize.Height);
// canvas.Measure(size);
// canvas.Arrange(new Rect(new System.Windows.Point(exportContainer.Location.X,exportContainer.Location.Y),size ));
// canvas.UpdateLayout();
// var exportArrange = exportContainer.GetArrangeStrategy();
// exportArrange.Arrange(exportContainer);
}
// InternalRun(item as IExportContainer);
} else {
if (acceptor != null) {
Console.WriteLine("..Item...");
acceptor.Accept(visitor);
var uiElement = visitor.UIElement;
if (canvas != null) {
Canvas.SetLeft(uiElement, item.Location.X - exportContainer.Location.X);
Canvas.SetTop(uiElement, item.Location.Y - exportContainer.Location.Y);
canvas.Children.Add(uiElement);
}
fixedPage.Children.Add(uiElement);
}
}
}
}
private void FindBiggestRectangle (IExportContainer container)
{
BiggestRectangle = Rectangle.Empty;
/*
foreach (var item in container.ExportedItems)
{
if (item.DesiredSize.Height > BiggestRectangle.Size.Height)
{
BiggestRectangle = new Rectangle(new Point(container.Location.X + item.Location.X,
container.Location.Y + item.Location.Y)
, item.DesiredSize);
}
}
*/
foreach (var item in container.ExportedItems
.Where(item => item.DesiredSize.Height > BiggestRectangle.Size.Height))
{
BiggestRectangle = new Rectangle(new Point(container.Location.X + item.Location.X,
container.Location.Y + item.Location.Y)
,item.DesiredSize);
}
}
protected void AddSectionToPage(IExportContainer header)
{
header.Parent = CurrentPage;
CurrentPage.ExportedItems.Add(header);
}
public override void ExportBinary(IExportContainer container, Stream stream)
{
ExportBinary(container, stream, DefaultShaderExporterInstantiator);
}
private IExportText CreateCanGrowText(IExportContainer container) {
var secondItem = new ExportText(){
Name = "Item1",
Location = new Point(80,10),
Size = new Size (20,70),
DesiredSize = new Size (20,70),
CanGrow = true,
Parent = container
};
return secondItem;
}
protected override void ExportYAMLInner(IExportContainer container, YAMLMappingNode node)
{
base.ExportYAMLInner(container, node);
int index = 0;
SpriteMetaData[] sprites = new SpriteMetaData[m_sprites.Count];
foreach (KeyValuePair <Sprite, SpriteAtlas> kvp in m_sprites)
{
sprites[index++] = new SpriteMetaData(kvp.Key, kvp.Value);
}
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.Linear ? 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", (int)TextureImporterNPOTScale.None);
node.Add("lightmap", false);
node.Add("compressionQuality", 50);
SpriteImportMode spriteMode;
uint extrude;
SpriteMeshType meshType;
SpriteAlignment alignment;
Vector2f pivot;
Vector4f border;
float pixelPerUnit;
switch (m_sprites.Count)
{
case 0:
{
spriteMode = SpriteImportMode.Single;
extrude = 1;
meshType = SpriteMeshType.Tight;
alignment = SpriteAlignment.Center;
pivot = new Vector2f(0.5f, 0.5f);
border = default;
pixelPerUnit = 100.0f;
}
break;
case 1:
{
Sprite sprite = m_sprites.Keys.First();
if (sprite.Rect == sprite.RD.TextureRect)
{
spriteMode = sprite.Name == m_texture.Name ? SpriteImportMode.Single : SpriteImportMode.Multiple;
}
else
{
spriteMode = SpriteImportMode.Multiple;
}
extrude = sprite.Extrude;
meshType = sprite.RD.MeshType;
alignment = SpriteAlignment.Custom;
pivot = sprite.Pivot;
border = sprite.Border;
pixelPerUnit = sprite.PixelsToUnits;
}
break;
default:
{
Sprite sprite = m_sprites.Keys.First();
spriteMode = SpriteImportMode.Multiple;
extrude = sprite.Extrude;
meshType = sprite.RD.MeshType;
alignment = SpriteAlignment.Center;
pivot = new Vector2f(0.5f, 0.5f);
border = default;
pixelPerUnit = sprite.PixelsToUnits;
}
break;
}
node.Add("spriteMode", (int)spriteMode);
node.Add("spriteExtrude", extrude);
node.Add("spriteMeshType", (int)meshType);
node.Add("alignment", (int)alignment);
node.Add("spritePivot", pivot.ExportYAML(container));
node.Add("spriteBorder", border.ExportYAML(container));
node.Add("spritePixelsToUnits", pixelPerUnit);
node.Add("alphaUsage", (int)TextureImporterAlphaSource.FromInput);
node.Add("alphaIsTransparency", true);
node.Add("spriteTessellationDetail", -1.0f);
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(m_texture.TextureFormat.ToDefaultFormat());
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);
}
public YAMLNode ExportYAML(IExportContainer container)
{
return(ExportYAMLRoot(container));
}
void MeasureAndArrangeContainer(IExportContainer container){
container.DesiredSize = MeasureElement(container);
ArrangeContainer(container);
}
public void SetParent(IExportContainer parent, List<IExportColumn> convertedItems)
{
foreach (var item in convertedItems) {
item.Parent = parent;
}
}
/// <summary>
/// Export object's content in such formats as txt or png
/// </summary>
public virtual void ExportBinary(IExportContainer container, Stream stream)
{
throw new NotSupportedException($"Type {GetType()} doesn't support binary export");
}
public void Export(IExportContainer container, IEnumerable <Object> assets, string path)
{
throw new NotSupportedException();
}
public void Export(IExportContainer container, Object asset, string path)
{
Export(container, asset, path, null);
}
public KeyframeTpl <T> Convert(IExportContainer container)
{
return(KeyframeTplConverter.Convert(container, ref this));
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
return(base.ExportYAMLRoot(container));
}
public Heightmap Convert(IExportContainer container)
{
return(HeightmapConverter.Convert(container, ref this));
}
protected sealed override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
throw new NotSupportedException();
}
static List<IExportColumn> CreateCanGrowList(IExportContainer container)
{
var canGrowList = new List<IExportColumn>();
foreach (var element in container.Descendents()) {
if (element.CanGrow) {
canGrowList.Add(element);
}
}
return canGrowList;
}
public YAMLNode ExportYAML(IExportContainer container)
{
return(new YAMLScalarNode(ID == 0 ? string.Empty : $"Unknown_{unchecked((uint)ID)}"));
}
void RenderDataRow(IExportContainer row)
{
var r = new Rectangle(containerLocation,row.DisplayRectangle.Size).ToXRect();
PdfHelper.FillRectangle(r,row.BackColor,xGraphics);
foreach (var element in row.ExportedItems) {
var acceptor = element as IAcceptor;
acceptor.Accept(this);
}
}
Rectangle CreateItemRectangle(IExportContainer container)
{
var containerRect = new Rectangle(container.Location,container.DesiredSize);
var child = container.ExportedItems[0];
var childLocation = new Point(containerRect.Left + child.Location.X, containerRect.Top + child.Location.Y);
var childRect = new Rectangle(childLocation, child.DesiredSize);
return childRect;
}
public override void ExportBinary(IExportContainer container, Stream stream)
{
if (IsReadLoadType(container.Version))
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, FSBResource.Source))
{
if (res == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{ValidName}' because resources file '{FSBResource.Source}' hasn't been found");
return;
}
if (StreamedResource.IsReadSize(container.Version))
{
using (PartialStream resStream = new PartialStream(res.Stream, res.Offset, res.Size))
{
resStream.Position = FSBResource.Offset;
resStream.CopyStream(stream, FSBResource.Size);
}
}
else
{
// I think they read data by its type for this verison, so I can't even export raw data :/
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{ValidName}' because of unknown size");
}
}
}
else
{
if (IsReadStreamingInfo(container.Version))
{
if (LoadType == AudioClipLoadType.Streaming)
{
if (m_audioData == null)
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, StreamingInfo.Path))
{
if (res == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{ValidName}' because resources file '{StreamingInfo.Path}' hasn't been found");
return;
}
using (PartialStream resStream = new PartialStream(res.Stream, res.Offset, res.Size))
{
resStream.Position = StreamingInfo.Offset;
resStream.CopyStream(stream, StreamingInfo.Size);
}
}
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
}
public void Export(IExportContainer container, IEnumerable <Object> assets, string path, Action <IExportContainer, Object, string> callback)
{
throw new NotSupportedException();
}
public virtual Object Convert(IExportContainer container)
{
return(this);
}
void RenderContainerInternal(IExportContainer graphicsContainer,Point savedLocation)
{
if (graphicsContainer.ExportedItems.Count > 0) {
foreach (var element in graphicsContainer.ExportedItems) {
if (IsGraphicsContainer(element)) {
var loc = new Point(containerLocation.X + element.Location.X,
containerLocation.Y + element.Location.Y);
containerLocation = loc;
RenderGraphicsContainer(element);
containerLocation = savedLocation;
} else {
var acceptor = AsAcceptor(element);
acceptor.Accept(this);
}
}
}
}
public YAMLNode ExportYAML(IExportContainer container)
{
throw new NotSupportedException();
}
static void SetCanGrowToTrue(IExportContainer container)
{
container.ExportedItems[0].Location = new Point(80, 10);
container.ExportedItems[0].Size = new Size(20, 70);
container.ExportedItems[0].CanGrow = true;
}
private YAMLNode ExportDeferred(IExportContainer container)
{
const string DefferedShading = "Hidden/Internal-DeferredShading";
return(IsReadDeferred(container.Version) ? Deferred.ExportYAML(container) : Deferred.ExportYAML(container, DefferedShading));
}
private YAMLNode ExportDeferredReflections(IExportContainer container)
{
const string DefferedReflection = "Hidden/Internal-DeferredReflections";
return(IsReadDeferredReflections(container.Version) ? DeferredReflections.ExportYAML(container) : DeferredReflections.ExportYAML(container, DefferedReflection));
}
public override YAMLNode ExportYAML(IExportContainer container)
{
return(Pointer.ExportYAML(container));
}