CudaTexture.h

#pragma once
#include "common.hpp"
#include "Cuda.h"
#include "Texture.h"

#include <shrUtils.h>
#include <cutil_inline.h>
#include <cutil_gl_inline.h>
#include <channel_descriptor.h>

#include <vector_types.h>
#include <vector_functions.h>
#include <driver_functions.h>
#include <cuda_gl_interop.h>

//1 Dimensionale Texturen werden von Cuda aus irgendeinen Grund nicht unterstützt!!!!
template <class T, unsigned int N> 
class CudaTexture : public Cuda
{
public:
        enum CudaTextureType
        {
                CTT_CUDA,
                CTT_CUDA_RW,
                CTT_CUDA_READ_OGL_TEXTURE,
                CTT_READ_WRITE_CUDA_AND_OGL
        };

public:
        CudaTexture()
        {

        };

        CudaTexture(unsigned int width, unsigned int height, unsigned int depth) : m_type(CTT_CUDA)
        {
                res = make_cudaExtent(width, height, depth);
                Create();
        };

        CudaTexture(unsigned int width, unsigned int height, unsigned int depth, bool write) : m_type(CTT_CUDA_RW)
        {
                res = make_cudaExtent(width, height, depth);
                Create();
        };

        CudaTexture(Texture::TexturePtr tex) : m_type(CTT_CUDA_READ_OGL_TEXTURE)
        {
                m_tex = tex;
                res.width = tex->m_width;
                res.height = tex->m_height;
                res.depth = tex->m_depth;

                Create();
        };

        CudaTexture(Texture::TexturePtr tex, bool write) : m_type(CTT_READ_WRITE_CUDA_AND_OGL)
        {
                m_tex = tex;
                res.width = tex->m_width;
                if(N > 1) res.height = tex->m_height;
                if(N > 2) res.depth = tex->m_depth;

                Create();
        };

        ~CudaTexture(void)
        {
                cudaFree( m_device );
                cudaFreeArray( m_volumeArray );
        };

        void Create()
        {
                if(m_type == CTT_CUDA_READ_OGL_TEXTURE || m_type == CTT_READ_WRITE_CUDA_AND_OGL)
                {
                        switch(N)
                        {
                        case 2:
                                cutilSafeCall(cudaGraphicsGLRegisterImage(&cudaRes, m_tex->GetTexName(), GL_TEXTURE_2D, cudaGraphicsMapFlagsReadOnly));
                                cudaGLRegisterBufferObject(m_tex->GetTexName());
                                break;
                        case 3:
                                cutilSafeCall(cudaGraphicsGLRegisterImage(&cudaRes, m_tex->GetTexName(), GL_TEXTURE_3D, cudaGraphicsMapFlagsReadOnly));
                                cudaGLRegisterBufferObject(m_tex->GetTexName());
                                break;
                        }
                }

                if(m_type == CTT_CUDA || m_type == CTT_CUDA_RW || m_type == CTT_READ_WRITE_CUDA_AND_OGL)
                {
                        CreateCuda();
                }
        };

        void Map()
        {
                cutilSafeCall(cudaGraphicsMapResources(1, &cudaRes, 0));
                cutilSafeCall(cudaGraphicsSubResourceGetMappedArray(&m_volumeArray, cudaRes, 0, 0));
        };

        void Unmap()
        {
                cutilSafeCall(cudaGraphicsUnmapResources(1, &cudaRes, 0));
        };

        void Reset()
        {
                cutilSafeCall(cudaMemset(m_device,0, sizeof(T) * dim[0] * max(1, dim[1]) * max(1, dim[2])));
        };

        cudaArray* GetCudaTexture()
        {
                return m_volumeArray;
        };

        T* GetCudaArray()
        {
                return m_device;
        };
        
        cudaExtent GetCudaExtend()
        {
                return res;
        };

private:
        void CreateCuda()
        {
                desc = cudaCreateChannelDesc<T>();
                
                switch(N)
                {
                case 1:
                        std::cout << "Create Array" << std::endl;
                        if(m_type == CTT_CUDA_RW) cutilSafeCall(cudaMalloc((void**)&m_device, sizeof(T)*res.width));
                        cutilSafeCall(cudaMallocArray(&m_volumeArray, &desc, res.width,1));
                        break;
                case 2:
                        cutilSafeCall(cudaMalloc((void**)&m_device, sizeof(T)*res.width * res.height));
                        cutilSafeCall(cudaMallocArray(&m_volumeArray, &desc, res.width, res.height));
                        break;
                case 3:
                        cutilSafeCall(cudaMalloc((void**)&m_device, sizeof(T)*res.width * res.height * res.depth));
                        cutilSafeCall(cudaMalloc3DArray(&m_volumeArray, &desc, res));
                        break;
                }

                // copy data to array
                switch(N)
                {
                case 1: 
                        break;
                case 2: 
                        break;
                case 3:
                        ArrayCopy((void*)(m_device), m_volumeArray, (size_t)(sizeof(T)), res);  
                        break;
                }
        };

private:
        unsigned int m_type;

        T* m_device;
        cudaArray* m_volumeArray;
        struct cudaGraphicsResource* cudaRes;
        Texture::TexturePtr m_tex;

        cudaChannelFormatDesc desc;
        cudaExtent res;
};