Beispiel #1
0
    public void Build_SequentialArranger()
    {
        var codecFactory = new CodecFactory(new());
        var memorySource = new MemoryDataSource("TestMemoryFile", 2 * 256 * 512);

        SequentialArranger arranger = ArrangerBuilder
                                      .WithSingleLayout()
                                      .WithElementPixelSize(256, 512)
                                      .WithPixelColorType(PixelColorType.Direct)
                                      .WithName("SequentialTestArranger")
                                      .AsSequentialArranger(codecFactory)
                                      .WithDataFile(memorySource)
                                      .WithCodecName("PSX 16bpp")
                                      .Build();

        Assert.That(arranger.Layout == ElementLayout.Single);
        Assert.That(arranger.ArrangerElementSize == new Size(1, 1));
        Assert.That(arranger.ElementPixelSize == new Size(256, 512));
        Assert.That(arranger.ColorType == PixelColorType.Direct);
        Assert.That(arranger.Name == "SequentialTestArranger");
        Assert.That(arranger.ActiveCodec.Name == "PSX 16bpp");
        Assert.That(arranger.ActiveCodec.ColorType == PixelColorType.Direct);
        Assert.That(arranger.ActiveCodec.Layout == ImageLayout.Single);
        Assert.That(arranger.ActiveCodec.Width == 256);
        Assert.That(arranger.ActiveCodec.Height == 512);
        Assert.That(arranger.ActivePalette is null);
        Assert.That(arranger.ActiveDataSource.Name == "TestMemoryFile");
    }
Beispiel #2
0
    public async Task <SpriteResourceContext> DeserializeSprite(string fileName, MonsterMetadata metadata)
    {
        var dataFile   = new FileDataSource("monsterFile", fileName);
        var palEntries = metadata.ColorDepth == TileColorDepth.Bpp4 ? 16 : 8;

        var paletteSources = Enumerable.Range(0, palEntries)
                             .Select(x => (IColorSource) new FileColorSource(new BitAddress(PaletteOffset + 16 * metadata.PaletteID + x * 2, 0), Endian.Little))
                             .ToList();

        var pal = new Palette("monsterPalette", new ColorFactory(), ColorModel.Bgr15, paletteSources, true, PaletteStorageSource.Project);

        pal.DataSource = dataFile;

        Console.WriteLine(pal.GetNativeColor(0).ToString());

        int arrangerWidth  = metadata.TileSetSize == TileSetSize.Small ? 8 : 16;
        int arrangerHeight = metadata.TileSetSize == TileSetSize.Small ? 8 : 16;

        var formData    = new byte[arrangerWidth * arrangerHeight / 8];
        int formAddress = metadata.TileSetSize == TileSetSize.Small ? FormSmallOffset + 8 * metadata.FormID : FormLargeOffset + 32 * metadata.FormID;

        //dataFile.Stream.Seek(formAddress, SeekOrigin.Begin);
        //var length = await dataFile.Stream.ReadAsync(formData, 0, formData.Length);
        dataFile.Read(new BitAddress(formAddress, 0), formData.Length * 8, formData);

        if (metadata.TileSetSize == TileSetSize.Large) // Requires endian swapping the tile form
        {
            EndianSwapArray(formData);
        }
        var bitStream = BitStream.OpenRead(formData, formData.Length * 8);

        var arranger = ArrangerBuilder.WithTiledLayout()
                       .WithArrangerElementSize(arrangerWidth, arrangerHeight)
                       .WithElementPixelSize(8, 8)
                       .WithPixelColorType(PixelColorType.Indexed)
                       .WithName("monsterArranger")
                       .AsScatteredArranger()
                       .Build();

        int elementsStored = 0;
        int tileOffset     = TileSetOffset + 8 * metadata.TileSetID;
        int tileSize       = metadata.ColorDepth == TileColorDepth.Bpp4 ? 32 : 24;

        for (int y = 0; y < arrangerHeight; y++)
        {
            for (int x = 0; x < arrangerWidth; x++)
            {
                if (bitStream.ReadBit() == 1)
                {
                    IGraphicsCodec codec   = metadata.ColorDepth == TileColorDepth.Bpp4 ? new Snes4bppCodec(8, 8) : new Snes3bppCodec(8, 8);
                    var            element = new ArrangerElement(x * 8, y * 8, dataFile, new BitAddress(tileOffset * 8), codec, pal);
                    tileOffset += tileSize;
                    arranger.SetElement(element, x, y);
                    elementsStored++;
                }
            }
        }

        return(new SpriteResourceContext(dataFile, pal, arranger));
    }
Beispiel #3
0
    public void Build_ScatteredArranger()
    {
        ScatteredArranger arranger = ArrangerBuilder
                                     .WithTiledLayout()
                                     .WithArrangerElementSize(8, 16)
                                     .WithElementPixelSize(8, 8)
                                     .WithPixelColorType(PixelColorType.Indexed)
                                     .WithName("ScatteredTestArranger")
                                     .AsScatteredArranger()
                                     .Build();

        Assert.That(arranger.Layout == ElementLayout.Tiled);
        Assert.That(arranger.ArrangerElementSize == new Size(8, 16));
        Assert.That(arranger.ElementPixelSize == new Size(8, 8));
        Assert.That(arranger.ColorType == PixelColorType.Indexed);
        Assert.That(arranger.Name == "ScatteredTestArranger");
    }