A smaller class for manipulating texture data before upload

Post those lines of code you feel like sharing or find what you require for your project here; or simply use them as tutorials.
Post Reply
devsh
Competition winner
Posts: 2057
Joined: Tue Dec 09, 2008 6:00 pm
Location: UK
Contact:

A smaller class for manipulating texture data before upload

Post by devsh »

Code: Select all

 
 
#include "IReferenceCounted.h"
#include "SColor.h"
 
namespace irr
{
namespace video
{
 
struct CImageData : public IReferenceCounted
{
    void*       data;
 
    uint32_t    offset[3];
    uint32_t    size[3];
    uint32_t    mipLevelHint;
    uint32_t    colorFormat;
public:
    CImageData()
    {
        data = NULL;
 
        offset[0] = 0;
        offset[1] = 0;
        offset[2] = 0;
 
        size[0] = 0;
        size[1] = 0;
        size[2] = 0;
 
        mipLevelHint = 0;
 
        colorFormat = ECF_UNKNOWN;
    }
 
    CImageData(void* inData, uint32_t inOffset[3], uint32_t inSize[3],
               const uint32_t& inMipLevel, const ECOLOR_FORMAT& inFmt,
               const bool& dataAllocatedWithMallocAndCanTake=false)
    {
        memcpy(offset,inOffset,3*sizeof(uint32_t));
        memcpy(size,inSize,3*sizeof(uint32_t));
 
        mipLevelHint = inMipLevel;
 
        colorFormat = inFmt;
 
 
        if (dataAllocatedWithMallocAndCanTake)
            data = inData;
        else
        {
            size_t imgByteSize = getImageDataSizeInBytes();
            data = malloc(imgByteSize);
            memcpy(data,inData,imgByteSize);
        }
    }
 
    virtual ~CImageData()
    {
        if (data)
            free(data);
    }
 
    //! Returns pointer to raw data
    const void* getData() {return data;}
 
    //! Returns offset in width,height and depth of image slice.
    const uint32_t* getOffset() const {return offset;}
 
    //! Returns width,height and depth of image slice.
    const uint32_t* getSize() const {return size;}
 
    //!
    const uint32_t& getSupposedMipLevel() const {return mipLevelHint;}
 
    //! Returns bits per pixel.
    uint32_t getBitsPerPixel() const
    {
        return getBitsPerPixelFromFormat(colorFormat);
    }
 
    //! Returns image data size in bytes
    size_t getImageDataSizeInBytes() const
    {
        size_t lineSize = getPitch();
        return lineSize*static_cast<size_t>(size[1])*static_cast<size_t>(size[2]);
    }
 
    //! Returns image data size in pixels
    size_t getImageDataSizeInPixels() const
    {
        return static_cast<size_t>(size[0])*static_cast<size_t>(size[1])*static_cast<size_t>(size[2]);
    }
 
    //! Returns the color format
    const ECOLOR_FORMAT& getColorFormat() const {return colorFormat;}
 
    //! Returns pitch of image
    uint32_t getPitch() const
    {
        return (getBitsPerPixel()*size[0])/8;
    }
 
};
 
} // end namespace video
} // end namespace irr
 
 
Made this little class to facilitate passing around pixel data for all texture format types, such as: 1D textures, 2D textures, cube maps; and their respective arrays, as well as 3D textures;

The data within is opaque, and it has no manipulation functions, which makes it a perfect solution for passing compressed texture data around.

My idea is to pass an array of these to the old createTextureFromIImage function, and have the function use glTextureSubImage calls to upload parts or all of the texture.

This is because writing unified loaders for cubemaps, 2D arrays and other things obfuscates and hides simple concepts behind thick layers of abstraction.
Post Reply