# gltexturecubemap.h File Reference

/* This file is part of FineFramework project */
#ifndef FFW_GRAPHICS_TEXTURE_CUBEMAP
#define FFW_GRAPHICS_TEXTURE_CUBEMAP

#include "gltexture.h"
#include "glimagetype.h"

namespace ffw {
    class FFW_API GLTextureCubemap: public GLTexture {
    public:
        GLTextureCubemap();
        GLTextureCubemap(const GLTextureCubemap& other) = delete;
        GLTextureCubemap(GLTextureCubemap&& other) NOEXCEPT;
        virtual ~GLTextureCubemap() = default;
        GLTextureCubemap(GLsizei width, GLsizei height, GLenum internalformat, GLenum format,
            GLenum pixelformat, const GLvoid* pixels = nullptr);
        void resize(GLsizei width, GLsizei height);
        void setPixels(GLint level, GLint xoffset, GLint yoffset, GLsizei width,
            GLsizei height, GLint side, const GLvoid* pixels);
        void setPixels(GLint level, GLint side, const GLvoid* pixels);
        void getPixels(GLvoid* pixels);
        GLTextureCubemap& operator = (const GLTextureCubemap& other) = delete;
        GLTextureCubemap& operator = (GLTextureCubemap&& other) NOEXCEPT;

#ifdef FFW_MEDIA_IMAGE_BUFFER
        friend bool setFromBuffer(GLTextureCubemap& self, const ImageBuffer& image, const GLint side, const bool inverse);
#endif

    private:
        void setPixelsInternal(GLint level, GLint xoffset, GLint yoffset, 
            GLsizei width, GLsizei height, GLint side, const GLvoid* pixels);
        void setPixelsInternal(GLint level, GLint side, const GLvoid* pixels);
    };

#ifdef FFW_MEDIA_IMAGE_BUFFER
    inline bool setFromBuffer(GLTextureCubemap& self, const ImageBuffer& image, const GLint side, const bool inverse) {

        if (!image.isAllocated())return false;
        if (image.getDepth() > 1)return false;

        const auto openglType = getOpenGLImageType(image.getImageType());
        if (!openglType) {
            return false;
        }

        if (image.isCompressed() && inverse)return false;

        if (self.isCreated()) {
            self.bind();
            for (auto m = 0; m <= image.getNumOfMipMaps() - 1; m++) {

                if (inverse) {
                    if (m != 0)self.setPixelsInternal(m, side, nullptr); // Create mipmap
                    for (auto i = 0; i < image.getHeight(m); i++) {
                        const auto ptr = &image.getMipMapPtr(m)[image.getStrideSize(m) * i];
                        self.setPixelsInternal(
                            m, 0, image.getHeight(m) - i - 1,
                            image.getWidth(m), 1, side, ptr
                        );
                    }
                }
                else {
                    if (m != 0)self.setPixelsInternal(m, side, nullptr); // Create mipmap
                    self.setPixelsInternal(
                        m, 0, 0, image.getWidth(m), image.getHeight(m),
                        side, image.getMipMapPtr(m)
                    );
                }
            }

            if (image.getNumOfMipMaps() > 0) {
                glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
                glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, image.getNumOfMipMaps() - 1);
            }
        }
        else {
            return false;
        }

        return true;
    }
#endif
};

inline void swap(ffw::GLTextureCubemap& first, ffw::GLTextureCubemap& second) NOEXCEPT {
    first.swap(second);
}
#endif