File size: 6,057 Bytes
41f85e5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/*
 * Copyright (c) 2023, Shukant Pal and Contributors
 * SPDX-License-Identifier: Apache-2.0
 */

#include <ktx.h>
#include "ktx_texture2.h"
#include <stddef.h>

ktxTextureMixed PY_ktxTexture2_Create(ktx_uint32_t glInternalformat,
                                      ktx_uint32_t vkFormat,
                                      ktx_uint32_t *pDfd,
                                      ktx_uint32_t baseWidth,
                                      ktx_uint32_t baseHeight,
                                      ktx_uint32_t baseDepth,
                                      ktx_uint32_t numDimensions,
                                      ktx_uint32_t numLevels,
                                      ktx_uint32_t numLayers,
                                      ktx_uint32_t numFaces,
                                      ktx_bool_t isArray,
                                      ktx_bool_t generateMipmaps,
                                      ktxTextureCreateStorageEnum storageAllocation)
{
    ktxTextureCreateInfo createInfo = {
        glInternalformat,
        vkFormat,
        pDfd,
        baseWidth,
        baseHeight,
        baseDepth,
        numDimensions,
        numLevels,
        numLayers,
        numFaces,
        isArray,
        generateMipmaps
    };

    ktxTexture2* newTex = NULL;
    KTX_error_code err = ktxTexture2_Create(&createInfo,
                                            storageAllocation,
                                            &newTex);

    return (ktxTextureMixed) {
        err,
        (ktxTexture*) newTex
    };
}

KTX_error_code PY_ktxTexture2_CompressAstcEx(ktxTexture2 *texture,
                                             ktx_bool_t verbose,
                                             ktx_uint32_t threadCount,
                                             ktx_uint32_t blockDimension,
                                             ktx_uint32_t mode,
                                             ktx_uint32_t qualityLevel,
                                             ktx_bool_t normalMap,
                                             ktx_bool_t perceptual,
                                             char *inputSwizzle)
{
    ktxAstcParams params = {
        .structSize = sizeof(ktxAstcParams),
        .verbose = verbose,
        .threadCount = threadCount,
        .blockDimension = blockDimension,
        .mode = mode,
        .qualityLevel = qualityLevel,
        .normalMap = normalMap,
        .perceptual = perceptual,
    };

    params.inputSwizzle[0] = inputSwizzle[0];
    params.inputSwizzle[1] = inputSwizzle[1];
    params.inputSwizzle[2] = inputSwizzle[2];
    params.inputSwizzle[3] = inputSwizzle[3];

    KTX_error_code err = ktxTexture2_CompressAstcEx(texture, &params);

    return err;
}

KTX_error_code PY_ktxTexture2_CompressBasisEx(ktxTexture2 *texture,
                                              ktx_bool_t uastc,
                                              ktx_bool_t verbose,
                                              ktx_bool_t noSSE,
                                              ktx_uint32_t threadCount,
                                              ktx_uint32_t compressionLevel,
                                              ktx_uint32_t qualityLevel,
                                              ktx_uint32_t maxEndpoints,
                                              float endpointRDOThreshold,
                                              ktx_uint32_t maxSelectors,
                                              float selectorRDOThreshold,
                                              char *inputSwizzle,
                                              ktx_bool_t normalMap,
                                              ktx_bool_t separateRGToRGB_A,
                                              ktx_bool_t preSwizzle,
                                              ktx_bool_t noEndpointRDO,
                                              ktx_bool_t noSelectorRDO,
                                              int uastcFlags,
                                              ktx_bool_t uastcRDO,
                                              float uastcRDOQualityScalar,
                                              ktx_uint32_t uastcRDODictSize,
                                              float uastcRDOMaxSmoothBlockErrorScale,
                                              float uastcRDOMaxSmoothBlockStdDev,
                                              ktx_bool_t uastcRDODontFavorSimplerModes,
                                              ktx_bool_t uastcRDONoMultithreading)
{
    ktxBasisParams params = {
        .structSize = sizeof(ktxBasisParams),
        .uastc = uastc,
        .verbose = verbose,
        .noSSE = noSSE,
        .threadCount = threadCount,
        .compressionLevel = compressionLevel,
        .qualityLevel = qualityLevel,
        .maxEndpoints = maxEndpoints,
        .endpointRDOThreshold = endpointRDOThreshold,
        .maxSelectors = maxSelectors,
        .selectorRDOThreshold = selectorRDOThreshold,
        // inputSwizzle skipped here
        .normalMap = normalMap,
        .separateRGToRGB_A = separateRGToRGB_A,
        .preSwizzle = preSwizzle,
        .noEndpointRDO = noEndpointRDO,
        .noSelectorRDO = noSelectorRDO,
        .uastcFlags = uastcFlags,
        .uastcRDO = uastcRDO,
        .uastcRDOQualityScalar = uastcRDOQualityScalar,
        .uastcRDOMaxSmoothBlockErrorScale = uastcRDOMaxSmoothBlockErrorScale,
        .uastcRDOMaxSmoothBlockStdDev = uastcRDOMaxSmoothBlockStdDev,
        .uastcRDODontFavorSimplerModes = uastcRDODontFavorSimplerModes,
        .uastcRDONoMultithreading = uastcRDONoMultithreading
    };

    params.inputSwizzle[0] = inputSwizzle[0];
    params.inputSwizzle[1] = inputSwizzle[1];
    params.inputSwizzle[2] = inputSwizzle[2];
    params.inputSwizzle[3] = inputSwizzle[3];

    KTX_error_code err = ktxTexture2_CompressBasisEx(texture, &params);

    return err;
}

KTX2_IMPL(ktx_uint32_t, vkFormat)
KTX2_IMPL(ktx_uint32_t, supercompressionScheme)