LotroDat/Source/Subfiles/DdsSubfile.cpp

///
// Created by Иван_Архипов on 24.11.2017.
//

#include "DdsSubfile.h"

#include "../BinaryData.h"
#include "../DatFile.h"
#include "../Common/DatException.h"
#include "../Database.h"
#include "../Common/CommonFunctions.h"

#include <algorithm>


namespace LOTRO_DAT {
    DdsSubfile::DdsSubfile() {}

    DdsSubfile::DdsSubfile(DatFile *dat, long long fragments_count, long long unknown1,
                                      long long file_id, long long file_offset, long long file_size,
                                      long long timestamp,
                                      long long version, long long block_size)
            : Subfile(dat, fragments_count, unknown1, file_id, file_offset, file_size, timestamp, version, block_size) {
        BinaryData header(20);
        dat_->ReadData(header, 10, file_offset_ + 8);
        compressed_ = header.CheckCompression();
    }

    FILE_TYPE DdsSubfile::FileType() const {
        return DDS;
    }

    std::string DdsSubfile::Extension() const {
        return ".dds";
    }

    bool DdsSubfile::PrepareAsBinary(BinaryData &data) {
        if (compressed_)
            data = data.DecompressData(4);

        BinaryData ddsData(data.size() - 24 + 128);
        for (int i = 0; i < 128; i++)
            ddsData[i] = 0;

        memcpy(ddsData.data() + 128, data.data() + 24, data.size() - 24);

        ddsData[0] = 0x44; // D
        ddsData[1] = 0x44; // D
        ddsData[2] = 0x53; // S
        ddsData[3] = 0x20;
        ddsData[4] = 0x7C;

        ddsData[8] = 7;
        ddsData[9] = 0x10;

        // width, height
        ddsData[12] = data[12];
        ddsData[13] = data[13];
        ddsData[14] = data[14];
        ddsData[15] = data[15];

        ddsData[16] = data[8];
        ddsData[17] = data[9];
        ddsData[18] = data[10];
        ddsData[19] = data[11];

        long long compression = data.ToNumber<4>(0x10);

        switch (compression) {
            case 20:        // 14 00 00 00 - 888 (R8G8B8)
                ddsData[0x4C] = 0x20;  // ?
                ddsData[0x50] = 0x40;  // compressed or not

                ddsData[0x58] = 0x18;  // bytes per pixel
                ddsData[0x5E] = 0xFF;
                ddsData[0x61] = 0xFF;
                ddsData[0x64] = 0xFF;
                break;
            case 21:        // 15 00 00 00 - 8888 (R8G8B8A8)
                ddsData[0x4C] = 0x20;  // ?
                ddsData[0x50] = 0x40;  // compressed or not

                ddsData[0x58] = 0x20;  // bytes per pixel
                ddsData[0x5E] = 0xFF;
                ddsData[0x61] = 0xFF;
                ddsData[0x64] = 0xFF;
                ddsData[0x6B] = 0xFF;
                break;
            case 28:        // 1C 00 00 00 - 332 (?)
                ddsData[0x4C] = 0x20;  // ?
                ddsData[0x50] = 0x40;  // compressed or not

                ddsData[0x58] = 0x08;  // bytes per pixel
                ddsData[0x5E] = 0xFF;
                ddsData[0x61] = 0xFF;
                ddsData[0x64] = 0xFF;
                break;
            case 827611204: // 44 58 54 31 - DXT1
                ddsData[76] = 32;
                ddsData[80] = 4;

                ddsData[84] = 68;
                ddsData[85] = 88;
                ddsData[86] = 84;
                ddsData[87] = 49;
                break;
            case 861165636: // 44 58 54 33 - DXT3
                ddsData[22] = 1;
                ddsData[76] = 32;
                ddsData[80] = 4;

                ddsData[84] = 68;
                ddsData[85] = 88;
                ddsData[86] = 84;
                ddsData[87] = 51;

                ddsData[108] = 8;
                ddsData[109] = 16;
                ddsData[110] = 64;
                break;
            case 894720068: // 44 58 54 35 - DXT5
                ddsData[10] = 8;
                ddsData[22] = 1;
                ddsData[28] = 1;
                ddsData[76] = 32;
                ddsData[80] = 4;

                ddsData[84] = 68;
                ddsData[85] = 88;
                ddsData[86] = 84;
                ddsData[87] = 53;

                ddsData[88] = 32;
                ddsData[94] = 255;
                ddsData[97] = 255;
                ddsData[100] = 255;
                ddsData[107] = 255;
                ddsData[109] = 16;
                break;
            default:
                throw DatException("Bad DdsSubfile::PrepareAsBinary() - unknown header format.", EXPORT_EXCEPTION);
        }
        data = ddsData;
        return true;
    }


    BinaryData DdsSubfile::MakeFromBinary(const BinaryData &data) {
        return data.CutData(128).CompressData();
    }

};