Texture.h

Go to the documentation of this file.

#ifndef GlobeEngine_Texture_h
#define GlobeEngine_Texture_h

#include "OpenGL_Includes.h"
#include "Buffer.h"
#include "TextureHandle.h"
#include "Image.h"
#include "Common.h"
#include <vmmlib/vector.hpp>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <memory>
#include <fstream>

#ifdef __APPLE__
#include <ApplicationServices/ApplicationServices.h>
#endif

namespace ge {

    // default config is GL_CLAMP_TO_EDGE
    template <int D> class TextureWrapParameter
    {
    public:
        TextureWrapParameter(){
            for (int i = 0; i<D; i++) {
                this->param[i] = GL_CLAMP_TO_EDGE;
            }
        }

        TextureWrapParameter(const std::shared_ptr<TextureWrapParameter> copy){
            for (int i = 0; i<D; i++) {
                this->param[i] = copy->param[i];
            }
        }

        GLint param[D];
    };

    class TextureWrapParameter1D : public TextureWrapParameter< 1 >
    {
    public:
        TextureWrapParameter1D(GLint _in) {
            this->param[0] = _in;
        }
    };

    class TextureWrapParameter2D : public TextureWrapParameter< 2 >
    {
    public:
        TextureWrapParameter2D() {
            this->param[0] = GL_CLAMP_TO_EDGE;
            this->param[1] = GL_CLAMP_TO_EDGE;
        }

        TextureWrapParameter2D(GLint _s, GLint _t) {
            this->param[0] = _s;
            this->param[1] = _t;
        }
    };

    class TextureWrapParameter3D : public TextureWrapParameter< 3 >
    {
    public:
        TextureWrapParameter3D(GLint _s, GLint _t, GLint _r) {
            this->param[0] = _s;
            this->param[1] = _t;
            this->param[2] = _r;
        }
    };

    // default config is GL_NEAREST
    struct TextureMinMagParameters
    {
        GLint min;
        GLint mag;

        TextureMinMagParameters() {
            min = GL_NEAREST; mag = GL_NEAREST;
        }

        TextureMinMagParameters(GLint _min, GLint _mag){
            min = _min; mag = _mag;
        }

        TextureMinMagParameters(const std::shared_ptr<TextureMinMagParameters> copy){
            min = copy->min;
            mag = copy->mag;
        }

        void set(GLint _min, GLint _mag){
            min = _min; mag = _mag;
        }
    };

    class TextureTypeInternals
    {
    public:
        short compCount; // number of color components in pixelformat
        
        GLint colorComponents;  
        GLenum pixelformat;     
        GLenum datatype;        
        TextureTypeInternals(){ 
            compCount=0;
            colorComponents = 0; 
            pixelformat = 0; 
            datatype = 0; }

        TextureTypeInternals(GLint _colorComponents, GLenum _pixelformat, GLenum _datatype){
            this->set(_colorComponents, _pixelformat,_datatype);
        }

        TextureTypeInternals(const std::shared_ptr<TextureTypeInternals> copy){
            colorComponents = copy->colorComponents;
            pixelformat = copy->pixelformat;
            datatype = copy->datatype;
            this->setComponentCount();
        }
        
        void set(GLint _colorComponents, GLenum _pixelformat, GLenum _datatype){
            colorComponents = _colorComponents;
            pixelformat = _pixelformat;
            datatype = _datatype;
            this->setComponentCount();
        }
        
        void setComponentCount(){


            if (pixelformat == GL_RED || pixelformat == GL_R32F ||
                pixelformat == GL_R8I || pixelformat == GL_R8 ||
                pixelformat == GL_R16 || pixelformat == GL_R16F ||
                pixelformat == GL_R16I || pixelformat == GL_R16UI ||
                pixelformat == GL_R32UI || pixelformat == GL_R32I)
            {
                compCount = 1;
            }
            else if (pixelformat == GL_RGB || pixelformat == GL_BGR){
                compCount = 3;
            }else if(pixelformat == GL_RGBA || pixelformat == GL_RGBA32F ||
                     pixelformat == GL_RGBA32I || pixelformat == GL_RGBA32UI ||
                     pixelformat == GL_BGRA || pixelformat == GL_RGBA32UI ||
                     pixelformat == GL_BGRA_INTEGER){
                compCount = 4;
            }else{
                compCount = 0;
            }
        }

        static TextureTypeInternals r32f(){ return TextureTypeInternals(GL_R32F, GL_RED, GL_FLOAT); };
        static TextureTypeInternals r32i(){ return TextureTypeInternals(GL_R32I, GL_RED_INTEGER, GL_INT); }
        static TextureTypeInternals r32ui(){ return TextureTypeInternals(GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT); }
        static TextureTypeInternals r16us(){ return TextureTypeInternals(GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT); }
        static TextureTypeInternals r16ui(){ return TextureTypeInternals(GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_INT); }
        static TextureTypeInternals r16f(){ return TextureTypeInternals(GL_R16F, GL_RED, GL_HALF_FLOAT); }
        static TextureTypeInternals rg16f(){ return TextureTypeInternals(GL_RG16F, GL_RG, GL_HALF_FLOAT); }
        static TextureTypeInternals rg8(){ return TextureTypeInternals(GL_RG, GL_RG, GL_UNSIGNED_BYTE); }
        static TextureTypeInternals rgb8(){ return TextureTypeInternals(GL_RGB, GL_RGB, GL_UNSIGNED_BYTE); }
        static TextureTypeInternals rgba8(){ return TextureTypeInternals(GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE); }
        static TextureTypeInternals rgba8i(){ return TextureTypeInternals(GL_RGBA, GL_RGBA_INTEGER, GL_INT); }
        static TextureTypeInternals rgba8ui(){ return TextureTypeInternals(GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_INT); }
        static TextureTypeInternals rgba32f(){ return TextureTypeInternals(GL_RGBA32F, GL_RGBA, GL_FLOAT); }
        static TextureTypeInternals rgba32i(){ return TextureTypeInternals(GL_RGBA32I, GL_RGBA_INTEGER, GL_INT); }
        static TextureTypeInternals rgba32ui(){ return TextureTypeInternals(GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT); }
    };
    
    //typedef TextureTypeInternals<4> rgba8(){ return TextureTypeInternals<4>(GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE); }
    
    //typedef Texture2D <TextureTypeInternals<count of components, component type, pixelformat, bit coverage=datatype> > Texture2Di;
    //typedef Texture2D <TextureTypeInternals<1, GLint, GL_RED_INTEGER, GL_INT> > Texture2Di;
    //typedef Texture2D <TextureTypeInternals<1, GLushort, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT_4_4_4_4_REV> > Texture2Dus4444Rev;

    struct TextureDepthProperties
    {       
        GLint compareFunc;
        GLint mode;
        GLint compareMode;

        TextureDepthProperties(){
            compareFunc = 0;
            mode = 0;
            compareMode = 0;
        }

        TextureDepthProperties(GLint _compareFunc, GLenum _mode, GLenum _compareMode){
            compareFunc = _compareFunc;
            mode = _mode;
            compareMode = _compareMode;
        }

        TextureDepthProperties(const std::shared_ptr<TextureDepthProperties> copy){
            compareFunc = copy->compareFunc;
            mode = copy->mode;
            compareMode = copy->compareMode;
        }
    };

    template <typename WRAP> class TextureProperties
    {
    public:
        TextureProperties(){ }
        TextureProperties(TextureTypeInternals _type,
            TextureMinMagParameters _minmag, 
            WRAP _wrap)
        {
            this->type = _type;
            this->minmag = _minmag;
            this->wrap = _wrap;
        }

        TextureProperties(const std::shared_ptr<TextureProperties> copy) {
            this->wrapProperties = copy->wrapProperties;
            this->minmagParameters = copy->minmagParameters;
            this->type = copy->type;
        }

        TextureTypeInternals type;
        TextureMinMagParameters minmag;
        WRAP wrap;
    };

    typedef TextureProperties<TextureWrapParameter1D> TextureProperties1D;
    typedef TextureProperties<TextureWrapParameter2D> TextureProperties2D;
    typedef TextureProperties<TextureWrapParameter3D> TextureProperties3D;
    
    template <int D, typename T, typename PROPERTIES> class TextureType : public TextureHandle
    {
    public:
        TextureType() {
            data = NULL;
            clear();
        }

        ~TextureType() {
            clear();
        }

        void clear()
        {
            for (int i = 0; i<D; i++) {
                this->dim[i] = 0;
            }
            this->name = "";
            if (data != NULL) { 
                //delete [] data; 
            } 
            data = NULL;
        }

        int countPixel() const {
            int res = 1;
            for (int i = 0; i<D; i++) {
                res *= this->dim[i];
            }
            return res;
        }

        void setMinMagParameter(TextureMinMagParameters _minmag)
        {
            this->bind();
            this->properties.minmag = _minmag;
            glTexParameteri(this->target, GL_TEXTURE_MIN_FILTER, this->properties.minmag.min);
            glTexParameteri(this->target, GL_TEXTURE_MAG_FILTER, this->properties.minmag.mag);
            this->getOpenGLError("error while setMinMagParameter()\n");
        }

        void generateMipMaps() {
            this->bind();
            glGenerateMipmap(this->target);
        }

#ifndef GENGINE_GL_BELOW_410    

        void bindTextureForCompute(GLuint _unit, GLint _level,
            GLboolean _layered, GLint _layer, GLenum _access) {
            return glBindImageTexture(_unit, this->handle, _level, _layered,
                _layer, _access, this->internalFormat);
        }
#endif

        friend std::ostream& operator<< (std::ostream &out, const TextureType<D, T, PROPERTIES> &tex) {
            out << "Dim: (" << tex.dim[0];
            for (int i = 1; i<D; i++) {
                out << "," << tex.dim[i];
            }
            out << ")";
            return out;
        }

        std::string getName() { return this->name; }
        short getHeight() const { return this->dim[0]; }
        short getWidth() const { return this->dim[1]; }
        int getStorageSize() const { return this->countPixel() * this->properties.type.compCount; }
        vmml::vector< D, short> getDimensions() const { return this->dim; }
        GLint getInternalFormat() const { return this->properties.type.colorComponents; }
        GLenum getFormat() const { return this->properties.type.pixelformat; }
        GLenum getType() const { return this->properties.type.datatype; }
        const T& getData() const { return data; }

        T* mapStoragePointer() {
            int storageSize = this->getStorageSize();
#ifndef GENGINE_GL_BELOW_410
            return this->textureBuffer.template mapBufferStorage<T>(storageSize);
#else
            return this->textureBuffer.template mapBuffer<T>(storageSize);
#endif
        }
        
    protected:
        // abstract methods to define in subclass
        virtual void setTextureData(T* _pixels) = 0;
        
        void loadDataToPBO(T* _data)
        {
            T* texBuffer = this->mapStoragePointer();
            //int storageSize = this->getStorageSize();
            memcpy(texBuffer, _data, this->getStorageSize()*sizeof(T));
            this->unmapStoragePointer();
        }
        
        // potentially not working because from texture bound?
        void unmapStoragePointer() {
            this->textureBuffer.unmapBuffer();
            this->textureBuffer.unbindBuffer();
        }
        
        void unpackPBO(){
            this->textureBuffer.bindBuffer();
            this->setTextureData(data);
            this->textureBuffer.unbindBuffer();
            this->unbind();
        }

        void setSize(vmml::vector< D, short> _dim) {
            this->dim = _dim;
        }

        vmml::vector< D, short> dim;
        T* data;
        std::string name;

        //TextureProperties< TextureWrapParameter< D > > properties;
        PROPERTIES properties;
        // for texture buffer objects
        ge::PixelUnpackBuffer textureBuffer;
    };

    /*
    * 1D Texture
    *
    * 2D Texture funktions used for 1D texture (resolution = width x 1)
    */
    template <typename T, typename PROPERTIES> class Texture1D : public TextureType< 1, T, PROPERTIES>
    {
    public:
        Texture1D() { }

        GLuint loadEmpty(short _width, TextureTypeInternals _type){
            this->properties.type = _type;
            this->setSize(vmml::Vector1s(_width));
            this->createHandle(GL_TEXTURE_2D);
            this->setMinMagParameter(TextureMinMagParameters(GL_NEAREST, GL_NEAREST));
            this->setWrapParameter(TextureWrapParameter1D(GL_CLAMP_TO_EDGE));
            this->setTextureData(this->data);
            return this->handle;
        }

        GLuint load(short _width, TextureTypeInternals _type, T* _data){
            this->loadEmpty(_width, _type);
            this->data = _data;
            this->setTextureData(this->data);
            return this->handle;
        }

        void setWrapParameter(TextureWrapParameter1D _wrap)
        {
            this->bind();
            this->properties.wrap = _wrap;
            glTexParameteri(this->target, GL_TEXTURE_WRAP_S, _wrap.param[0]);
        }

        void setTextureData(T* _pixels) {
            this->bind();
            glTexImage2D(this->target, 0, this->properties.type.colorComponents, this->dim[0], 1, 0, this->properties.type.pixelformat, this->properties.type.datatype, _pixels);
        }

    private:
    };
    
    typedef Texture1D <GLfloat, TextureProperties< TextureWrapParameter<1> > > Texture1Df;
    typedef Texture1D <GLubyte, TextureProperties< TextureWrapParameter<1> > > Texture1Dub;
    typedef Texture1D <GLubyte, TextureProperties< TextureWrapParameter<1> > > Texture1Drgb;
    typedef Texture1D <GLubyte, TextureProperties< TextureWrapParameter<1> > > Texture1Drgba;

    /*
    * 2D Texture
    *
    * 
    */
    template <typename T, typename PROPERTIES> class Texture2D : public TextureType< 2, T, PROPERTIES>
    {
    public:
        Texture2D() { }

        GLuint loadEmptyWithDefaultParameter(vmml::Vector2s _dim, TextureTypeInternals _type, bool _allocateTexImage = true){
            return this->loadEmpty(_dim, _type,
                TextureMinMagParameters(GL_NEAREST, GL_NEAREST),
                TextureWrapParameter2D(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE),
                _allocateTexImage);
        }

        GLuint loadEmpty(const vmml::Vector2s& _dim, TextureTypeInternals _type, 
            TextureMinMagParameters _minmag, TextureWrapParameter2D _wrap, bool _allocateTexImage = true){
            this->properties.type = _type;
            this->setSize(_dim);
            this->createHandle(GL_TEXTURE_2D);
            this->setMinMagParameter(_minmag);
            this->setWrapParameter(_wrap);
            if( _allocateTexImage )
                this->setTextureData(this->data);
            return this->handle;
        }

        GLuint load(const vmml::Vector2s& _dim, TextureTypeInternals _type,
            TextureMinMagParameters _minmag, TextureWrapParameter2D _wrap, T* _data) {
            this->loadEmpty(_dim,_type,_minmag,_wrap,false);
            this->data = _data;
            this->setTextureData(this->data);
            return this->handle;
        }

        GLuint loadWithDefaultParameter(const vmml::Vector2s& _dim, TextureTypeInternals _type, T* _data) {
            this->loadEmptyWithDefaultParameter(_dim, _type, false);
            this->data = _data;
            this->setTextureData(this->data);
            return this->handle;
        }

        GLuint loadSynchWithDefaultParameter(const vmml::Vector2s& _dim, TextureTypeInternals _type, T* _data) {
            this->loadEmptyWithDefaultParameter(_dim, _type, false);
            this->loadDataToPBO(_data);
            this->unpackPBO();
            return this->handle;
        }

        void preloadSyncWithDefaultParameter(const vmml::Vector2s& _dim, TextureTypeInternals _type, T* _data) {
            this->loadEmptyWithDefaultParameter(_dim, _type, false);
            this->loadDataToPBO(_data);
        }

        void preloadCommit() {
            this->unpackPBO();
            this->textureBuffer.clear();
        }
        
       /* void closeAsynchLoad() {
            this->unmapStoragePointer();
            this->unpackPBO();
        }*/
        
        GLuint loadFromImage(std::string _filename) {
            this->createHandle(GL_TEXTURE_2D);
            this->loadImage(_filename);
            this->setMinMagParameter(TextureMinMagParameters(GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR));
            this->setWrapParameter(TextureWrapParameter2D(GL_REPEAT, GL_REPEAT));
            this->setTextureData(this->data);
            this->generateMipMaps();
            return this->handle;
        }

#ifndef GENGINE_GL_BELOW_410
        void setTextureStorage(const vmml::Vector2s& _dim, GLsizei _levels, GLenum _internalFormat) {
            this->setSize(_dim);
            this->properties.type.colorComponents = _internalFormat;
            glTextureStorage2DEXT(this->handle, this->target, _levels, this->properties.type.colorComponents, this->dim[0], this->dim[1]);
        }
#endif

    protected:
        
        void loadImage(std::string _filename) {
            imageRef = std::make_shared<Image>();
            imageRef->load(_filename);
            this->setSize(vmml::Vector2s(imageRef->width, imageRef->height));
            this->properties.type = TextureTypeInternals(imageRef->internal_format, imageRef->pixel_format, imageRef->data_type);
            this->data = imageRef->data.rgba;
        }

        void setWrapParameter(TextureWrapParameter2D _wrap) {
            this->bind();
            this->properties.wrap = _wrap;
            glTexParameteri(this->target, GL_TEXTURE_WRAP_S, this->properties.wrap.param[0]);
            if (-1 != _wrap.param[1]) {
                glTexParameteri(this->target, GL_TEXTURE_WRAP_T, this->properties.wrap.param[1]);
            }
        }

        void setTextureData(T* _pixels) {
            this->bind();
            glTexImage2D(this->target, 0, this->properties.type.colorComponents, this->dim[0], this->dim[1], 0, this->properties.type.pixelformat, this->properties.type.datatype, _pixels);
        }

        std::shared_ptr<ge::Image> imageRef;

    };

    typedef Texture2D <GLint, TextureProperties< TextureWrapParameter<2> > > Texture2Di;
    typedef Texture2D <GLuint, TextureProperties< TextureWrapParameter<2> > > Texture2Dui;

    typedef Texture2D <GLshort, TextureProperties< TextureWrapParameter<2> > > Texture2Ds;
    typedef Texture2D <GLushort, TextureProperties< TextureWrapParameter<2> > > Texture2Dus;

    typedef Texture2D <GLfloat, TextureProperties< TextureWrapParameter<2> > > Texture2Df;
    typedef Texture2D <GLfloat, TextureProperties< TextureWrapParameter<2> > > Texture2Dhdr;

    typedef Texture2D <GLubyte, TextureProperties< TextureWrapParameter<2> > > Texture2Dub;
    typedef Texture2D <GLubyte, TextureProperties< TextureWrapParameter<2> > > Texture2Drg;
    typedef Texture2D <GLubyte, TextureProperties< TextureWrapParameter<2> > > Texture2Drgb;
    typedef Texture2D <GLubyte, TextureProperties< TextureWrapParameter<2> > > Texture2Drgba;
    // todo refactoring to
    //typedef Texture2D <TextureTypeInternals<1, GLint> > Texture2Di;
    
    /*
    * Depth Texture
    * 
    * typical types:
    *
    * TextureTypeInternals(GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT)
    * TextureDepthProperties(GL_LEQUAL, GL_INTENSITY, GL_COMPARE_R_TO_TEXTURE);
    *
    */
    template <typename T, typename PROPERTIES> class DepthTexture : public Texture2D<T, PROPERTIES>
    {
    public:
        DepthTexture() { }
        
        GLuint loadEmpty(const vmml::Vector2s& _dim, TextureTypeInternals _type,
                         TextureMinMagParameters _minmag, TextureWrapParameter2D _wrap, TextureDepthProperties _prop){
            this->type = _type;
            this->setSize(_dim);
            this->createHandle(GL_TEXTURE_2D);
            this->setMinMagParameter(_minmag);
            //this->setWrapParameter(_wrap);
            this->setDepthParameter(_prop);
            this->setTextureData(this->data);
            this->generateMipMaps();
            return this->handle;
        }
        
        GLuint loadEmpty(const vmml::Vector2s& _dim, TextureTypeInternals _type,
            TextureMinMagParameters _minmag, TextureWrapParameter2D _wrap){
            this->properties.type = _type;
            this->setSize(_dim);
            this->createHandle(GL_TEXTURE_2D);
            this->setMinMagParameter(_minmag);
            this->setWrapParameter(_wrap);
            if(_type.colorComponents == GL_STENCIL_INDEX){
                this->setDepthStencilMode(GL_STENCIL_INDEX);
            }
            this->setTextureData(this->data);
            this->generateMipMaps();
            return this->handle;
        }
        
        void setDepthParameter(TextureDepthProperties _prop)
        {
            this->bind();
            glTexParameteri(this->target, GL_TEXTURE_COMPARE_FUNC, _prop.compareFunc);
#ifndef __APPLE__
            glTexParameteri(this->target, GL_DEPTH_TEXTURE_MODE, _prop.mode);
#endif
            glTexParameteri(this->target, GL_TEXTURE_COMPARE_MODE, _prop.compareMode);
            this->getOpenGLError("error while setDepthParameter()\n");
        }

        /*
        *   set the texture lookup mode to the depth part (DEPTH_COMPONENT) or the
        *   stencil part (STENCIL_INDEX) of the texture.
        */
        void setDepthStencilMode(GLenum _mode)
        {
            this->bind();
#ifndef GENGINE_GL_BELOW_410
            glTexParameteri(this->target, GL_DEPTH_STENCIL_TEXTURE_MODE, _mode);
#endif
        }
    private:
        
        
        TextureDepthProperties depthProperties;
    };

    typedef DepthTexture <GLubyte, TextureProperties< TextureWrapParameter<2> > > DepthMap2Drgba;

    /*
    * 3D Texture
    *
    *
    */
    template <typename T, typename PROPERTIES> class Texture3D : public TextureType< 3, T, PROPERTIES>
    {
    public:
        Texture3D() { }
        GLuint load(const vmml::Vector3s& _dim, TextureTypeInternals _type, float* _data)
        {
            this->setSize(_dim);
            int sumDim = this->dim.x() * this->dim.y() * this->dim.z();

            this->createHandle(GL_TEXTURE_3D);
            this->properties.type = _type;
            this->setMinMagParameter(TextureMinMagParameters(GL_LINEAR, GL_LINEAR));
            this->setWrapParameter(ge::TextureWrapParameter3D(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE));
            this->setTextureData(_data);

            return this->handle;
        }
        
        GLuint loadEmpty(const vmml::Vector3s& _dim, TextureTypeInternals _type)
        {
            this->setSize(_dim);
            int sumDim = this->dim.x() * this->dim.y() * this->dim.z();
            
            this->createHandle(GL_TEXTURE_3D);
            this->properties.type = _type;
            this->setMinMagParameter(TextureMinMagParameters(GL_LINEAR, GL_LINEAR));
            this->setWrapParameter(ge::TextureWrapParameter3D(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE));
            
            return this->handle;
        }
        
        void setWrapParameter(TextureWrapParameter3D _wrap) {
            this->bind();
            glTexParameteri(this->target, GL_TEXTURE_WRAP_S, _wrap.param[0]);
            if (-1 != _wrap.param[1]) {
                glTexParameteri(this->target, GL_TEXTURE_WRAP_T, _wrap.param[1]);
            }
            if (-1 != _wrap.param[2]) {
                glTexParameteri(this->target, GL_TEXTURE_WRAP_R, _wrap.param[2]);
            }
        }

        void setTextureData(T* _pixels) {
            this->bind();
            glTexImage3D(this->target, 0, this->properties.type.colorComponents, this->dim[0], this->dim[1], this->dim[2], 0, this->properties.type.pixelformat, this->properties.type.datatype, _pixels);
        }

    private:
    };

    typedef Texture3D <GLint, TextureProperties< TextureWrapParameter<3> > > Texture3Di;
    typedef Texture3D <GLuint, TextureProperties< TextureWrapParameter<3> > > Texture3Dui;

    typedef Texture3D <GLshort, TextureProperties< TextureWrapParameter<3> > > Texture3Ds;
    typedef Texture3D <GLushort, TextureProperties< TextureWrapParameter<3> > > Texture3Dus;

    typedef Texture3D <GLfloat, TextureProperties< TextureWrapParameter<3> > > Texture3Df;
    typedef Texture3D <GLfloat, TextureProperties< TextureWrapParameter<3> > > Texture3Dhdr;

    typedef Texture3D <GLubyte, TextureProperties< TextureWrapParameter<3> > > Texture3Dub;
    typedef Texture3D <GLubyte, TextureProperties< TextureWrapParameter<3> > > Texture3Drgb;
    typedef Texture3D <GLubyte, TextureProperties< TextureWrapParameter<3> > > Texture3Drgba;

}
#endif