*

TextureConverter/TextureConverter.cpp

@@ -0,0 +1,126 @@
+#include <iostream>
+#include <DirectXTex.h>
+#include <fstream>
+#include <vector>
+#include <cstdint>
+
+
+
+int Morton(int t, int sx, int sy) {
+    int num1;
+    int num2 = num1 = 1;
+    int num3 = t;
+    int num4 = sx;
+    int num5 = sy;
+    int num6 = 0;
+    int num7 = 0;
+
+    while (num4 > 1 || num5 > 1) {
+        if (num4 > 1) {
+            num6 += num2 * (num3 & 1);
+            num3 >>= 1;
+            num2 *= 2;
+            num4 >>= 1;
+        }
+        if (num5 > 1) {
+            num7 += num1 * (num3 & 1);
+            num3 >>= 1;
+            num1 *= 2;
+            num5 >>= 1;
+        }
+    }
+
+    return num7 * sx + num6;
+}
+
+std::vector<std::uint8_t> DoSwizzle(std::vector<std::uint8_t> data, int width, int height, int blockSize, bool unswizzle) {
+    auto processed = std::vector<std::uint8_t>();
+    processed.resize(data.size());
+
+    auto heightTexels = height / 4;
+    auto heightTexelsAligned = (heightTexels + 7) / 8;
+    int widthTexels = width / 4;
+    auto widthTexelsAligned = (widthTexels + 7) / 8;
+    auto dataIndex = 0;
+
+    for (int y = 0; y < heightTexelsAligned; ++y) {
+        for (int x = 0; x < widthTexelsAligned; ++x) {
+            for (int t = 0; t < 64; ++t) {
+                int pixelIndex = Morton(t, 8, 8);
+                int num8 = pixelIndex / 8;
+                int num9 = pixelIndex % 8;
+                auto yOffset = (y * 8) + num8;
+                auto xOffset = (x * 8) + num9;
+
+                if (xOffset < widthTexels && yOffset < heightTexels) {
+                    auto destPixelIndex = yOffset * widthTexels + xOffset;
+                    int destIndex = blockSize * destPixelIndex;
+
+                    if (unswizzle)
+                        memcpy(processed.data() + destIndex, data.data() + dataIndex, blockSize);
+                    else
+                        memcpy(processed.data() + dataIndex, data.data() + destIndex, blockSize);
+                }
+
+                dataIndex += blockSize;
+            }
+        }
+    }
+
+    return processed;
+}
+
+
+
+
+std::vector<std::uint8_t> Swizzle(std::vector<std::uint8_t> data, int width, int height, int blockSize) {
+    return DoSwizzle(data, width, height, blockSize, false);
+}
+
+std::vector<std::uint8_t> UnSwizzle(std::vector<std::uint8_t> data, int width, int height, int blockSize) {
+    return DoSwizzle(data, width, height, blockSize, true);
+}
+
+
+int main()
+{
+
+
+    DirectX::ScratchImage image;
+    auto initResult = image.Initialize2D(DXGI_FORMAT::DXGI_FORMAT_BC4_UNORM, 1024, 1024, 1, 1);
+    auto img = image.GetImage(0, 0, 0);
+
+    auto cnt = image.GetImageCount();
+
+    auto images = image.GetImages();
+    for (int i = 0; i < cnt; ++i) {
+        auto img = images + i;
+        std::cout << "ID: " << i <<  " W: " << img->width << " H: " << img->height << " Row pitch: " << img->rowPitch << " Slice pitch: " << img->slicePitch << std::endl;
+
+    }
+
+   
+
+
+    //2097152
+    //""
+    auto readSize = img->slicePitch;
+    auto inFile = std::ifstream("D:/TextureExport/blt-armor-a-new-spec-mask.tga.1024_1024_unswizzled_page0_file103.dds", std::ios::binary);
+    
+    inFile.read((char*)img->pixels, readSize);
+    inFile.close();
+
+ /*   std::vector<std::uint8_t> mem;
+    mem.resize(img->slicePitch);
+    memcpy(mem.data(), img->pixels, img->slicePitch);
+
+    auto unswizzled = UnSwizzle(mem, 1024, 1024, 8);
+
+    memcpy(img->pixels, unswizzled.data(), img->slicePitch);*/
+
+    DirectX::SaveToDDSFile(*img, DirectX::DDS_FLAGS::DDS_FLAGS_NONE, L"F:/out.dds");
+
+    //img->pixels
+
+    std::cout << "Hello World!\n";
+}