nv_dds.h 11.2 KB
Newer Older
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
#ifndef __NV_DDS_H__
#define __NV_DDS_H__

#ifndef NVDDS_PROJECT //defined if building nv_dds library
#if _MSC_VER >= 1300
    #ifdef _DLL
        #pragma message("Note: including lib: nv_dds.lib\n")
        #pragma comment(lib, "nv_dds.lib")
    #else
        #error "Your project doesn't use the Multithreaded DLL Runtime"
    #endif
#endif
#endif


#if defined(WIN32)
#  include <windows.h>
#endif

#include <string>
#include <deque>
#include <assert.h>

#if defined(MACOS)
#include <OpenGL/gl.h>
#include <OpenGL/glext.h>
#else
#include <GL/gl.h>
#include <GL/glext.h>
#endif

namespace nv_dds
{
    // surface description flags
    const uint32_t DDSF_CAPS           = 0x00000001l;
    const uint32_t DDSF_HEIGHT         = 0x00000002l;
    const uint32_t DDSF_WIDTH          = 0x00000004l;
    const uint32_t DDSF_PITCH          = 0x00000008l;
    const uint32_t DDSF_PIXELFORMAT    = 0x00001000l;
    const uint32_t DDSF_MIPMAPCOUNT    = 0x00020000l;
    const uint32_t DDSF_LINEARSIZE     = 0x00080000l;
    const uint32_t DDSF_DEPTH          = 0x00800000l;

    // pixel format flags
    const uint32_t DDSF_ALPHAPIXELS    = 0x00000001l;
    const uint32_t DDSF_FOURCC         = 0x00000004l;
    const uint32_t DDSF_RGB            = 0x00000040l;
    const uint32_t DDSF_RGBA           = 0x00000041l;

    // dwCaps1 flags
    const uint32_t DDSF_COMPLEX         = 0x00000008l;
    const uint32_t DDSF_TEXTURE         = 0x00001000l;
    const uint32_t DDSF_MIPMAP          = 0x00400000l;

    // dwCaps2 flags
    const uint32_t DDSF_CUBEMAP         = 0x00000200l;
    const uint32_t DDSF_CUBEMAP_POSITIVEX  = 0x00000400l;
    const uint32_t DDSF_CUBEMAP_NEGATIVEX  = 0x00000800l;
    const uint32_t DDSF_CUBEMAP_POSITIVEY  = 0x00001000l;
    const uint32_t DDSF_CUBEMAP_NEGATIVEY  = 0x00002000l;
    const uint32_t DDSF_CUBEMAP_POSITIVEZ  = 0x00004000l;
    const uint32_t DDSF_CUBEMAP_NEGATIVEZ  = 0x00008000l;
    const uint32_t DDSF_CUBEMAP_ALL_FACES  = 0x0000FC00l;
    const uint32_t DDSF_VOLUME          = 0x00200000l;

    // compressed texture types
    const uint32_t FOURCC_DXT1 = 0x31545844l; //(MAKEFOURCC('D','X','T','1'))
    const uint32_t FOURCC_DXT3 = 0x33545844l; //(MAKEFOURCC('D','X','T','3'))
    const uint32_t FOURCC_DXT5 = 0x35545844l; //(MAKEFOURCC('D','X','T','5'))

    struct DXTColBlock
    {
        uint16_t col0;
        uint16_t col1;

        uint8_t row[4];
    };

    struct DXT3AlphaBlock
    {
        uint16_t row[4];
    };

    struct DXT5AlphaBlock
    {
        uint8_t alpha0;
        uint8_t alpha1;
        
        uint8_t row[6];
    };

    struct DDS_PIXELFORMAT
    {
        uint32_t dwSize;
        uint32_t dwFlags;
        uint32_t dwFourCC;
        uint32_t dwRGBBitCount;
        uint32_t dwRBitMask;
        uint32_t dwGBitMask;
        uint32_t dwBBitMask;
        uint32_t dwABitMask;
    };

    struct DDS_HEADER
    {
        uint32_t dwSize;
        uint32_t dwFlags;
        uint32_t dwHeight;
        uint32_t dwWidth;
        uint32_t dwPitchOrLinearSize;
        uint32_t dwDepth;
        uint32_t dwMipMapCount;
        uint32_t dwReserved1[11];
        DDS_PIXELFORMAT ddspf;
        uint32_t dwCaps1;
        uint32_t dwCaps2;
        uint32_t dwReserved2[3];
    };

    enum TextureType
    {
        TextureNone,
        TextureFlat,    // 1D, 2D, and rectangle textures
        Texture3D,
        TextureCubemap
    };

    class CSurface
    {
        public:
            CSurface();
            CSurface(unsigned int w, unsigned int h, unsigned int d, unsigned int imgsize, const unsigned char *pixels);
            CSurface(const CSurface &copy);
            CSurface &operator= (const CSurface &rhs);
            virtual ~CSurface();

            operator unsigned char*() const;

            virtual void create(unsigned int w, unsigned int h, unsigned int d, unsigned int imgsize, const unsigned char *pixels);
            virtual void clear();

            inline unsigned int get_width() const { return m_width; }
            inline unsigned int get_height() const { return m_height; }
            inline unsigned int get_depth() const { return m_depth; }
            inline unsigned int get_size() const { return m_size; }

        private:
            unsigned int m_width;
            unsigned int m_height;
            unsigned int m_depth;
            unsigned int m_size;

            unsigned char *m_pixels;   
    };

    class CTexture : public CSurface
    {
        friend class CDDSImage;

        public:
            CTexture();
            CTexture(unsigned int w, unsigned int h, unsigned int d, unsigned int imgsize, const unsigned char *pixels);
            CTexture(const CTexture &copy);
            CTexture &operator= (const CTexture &rhs);
            ~CTexture();

            void create(unsigned int w, unsigned int h, unsigned int d, unsigned int imgsize, const unsigned char *pixels);
            void clear();

            inline const CSurface &get_mipmap(unsigned int index) const
            { 
                assert(!m_mipmaps.empty());
                assert(index < m_mipmaps.size());
                
                return m_mipmaps[index]; 
            }

            inline void add_mipmap(const CSurface &mipmap)
            {
                m_mipmaps.push_back(mipmap);
            }

            inline unsigned int get_num_mipmaps() const { return (unsigned int)m_mipmaps.size(); }

        protected:
            inline CSurface &get_mipmap(unsigned int index)
            { 
                assert(!m_mipmaps.empty());
                assert(index < m_mipmaps.size());

                return m_mipmaps[index]; 
            }

        private:
            std::deque<CSurface> m_mipmaps;
    };

    class CDDSImage
    {
        public:
            CDDSImage();
            ~CDDSImage();

            void create_textureFlat(unsigned int format, unsigned int components, const CTexture &baseImage);
            void create_texture3D(unsigned int format, unsigned int components, const CTexture &baseImage);
            void create_textureCubemap(unsigned int format, unsigned int components,
                                       const CTexture &positiveX, const CTexture &negativeX, 
                                       const CTexture &positiveY, const CTexture &negativeY, 
                                       const CTexture &positiveZ, const CTexture &negativeZ);

            void clear();
            bool load(std::string filename, bool flipImage = true);
            bool save(std::string filename, bool flipImage = true);

            /*
            bool upload_texture1D();
            bool upload_texture2D(unsigned int imageIndex = 0, GLenum target = GL_TEXTURE_2D);
            bool upload_texture3D();
            bool upload_textureRectangle();
            bool upload_textureCubemap();
            */

            inline operator unsigned char*()
            { 
                assert(m_valid);
                assert(!m_images.empty());
                
                return m_images[0]; 
            }

            inline unsigned int get_width() 
            {
                assert(m_valid);
                assert(!m_images.empty());
                
                return m_images[0].get_width(); 
            }

            inline unsigned int get_height()
            {
                assert(m_valid);
                assert(!m_images.empty());
                
                return m_images[0].get_height(); 
            }

            inline unsigned int get_depth()
            {
                assert(m_valid);
                assert(!m_images.empty());
                
                return m_images[0].get_depth(); 
            }

            inline unsigned int get_size()
            {
                assert(m_valid);
                assert(!m_images.empty());

                return m_images[0].get_size();
            }

            inline unsigned int get_num_mipmaps() 
            { 
                assert(m_valid);
                assert(!m_images.empty());

                return m_images[0].get_num_mipmaps(); 
            }

            inline const CSurface &get_mipmap(unsigned int index) const
            { 
                assert(m_valid);
                assert(!m_images.empty());
                assert(index < m_images[0].get_num_mipmaps());

                return m_images[0].get_mipmap(index); 
            }

            inline const CTexture &get_cubemap_face(unsigned int face) const
            {
                assert(m_valid);
                assert(!m_images.empty());
                assert(m_images.size() == 6);
                assert(m_type == TextureCubemap);
                assert(face < 6);

                return m_images[face];
            }

            inline unsigned int get_components() { return m_components; }
            inline unsigned int get_format() { return m_format; }
            inline TextureType get_type() { return m_type; }

            inline bool is_compressed() 
            { 
                if ((m_format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) || 
                    (m_format == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) ||
                    (m_format == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT))
                    return true; 
                else
                    return false;
            }
            
            inline bool is_cubemap() { return (m_type == TextureCubemap); }
            inline bool is_volume() { return (m_type == Texture3D); }
            inline bool is_valid() { return m_valid; }

            inline bool is_dword_aligned()
            {
                assert(m_valid);

                int dwordLineSize = get_dword_aligned_linesize(get_width(), m_components*8);
                int curLineSize = get_width() * m_components;
                
                return (dwordLineSize == curLineSize);
            }
            
        private:
            unsigned int clamp_size(unsigned int size);
            unsigned int size_dxtc(unsigned int width, unsigned int height);
            unsigned int size_rgb(unsigned int width, unsigned int height);
            inline void swap_endian(void *val);

            // calculates 4-byte aligned width of image
            inline unsigned int get_dword_aligned_linesize(unsigned int width, unsigned int bpp)
            {
                return ((width * bpp + 31) & -32) >> 3;
            }

            void flip(CSurface &surface);
            void flip_texture(CTexture &texture);

            void swap(void *byte1, void *byte2, unsigned int size);
            void flip_blocks_dxtc1(DXTColBlock *line, unsigned int numBlocks);
            void flip_blocks_dxtc3(DXTColBlock *line, unsigned int numBlocks);
            void flip_blocks_dxtc5(DXTColBlock *line, unsigned int numBlocks);
            void flip_dxt5_alpha(DXT5AlphaBlock *block);

            void write_texture(const CTexture &texture, FILE *fp);
            
            unsigned int m_format;
            unsigned int m_components;
            TextureType m_type;
            bool m_valid;

            std::deque<CTexture> m_images;
    };
}
#endif