cube_atlas.h

Go to the documentation of this file.

/*
 * Copyright 2013 Jeremie Roy. All rights reserved.
 * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
 */
 
#ifndef CUBE_ATLAS_H_HEADER_GUARD
#define CUBE_ATLAS_H_HEADER_GUARD
 
 
#include <bgfx/bgfx.h>
 
namespace gfx
{
struct AtlasRegion
{
    enum Type
    {
        TYPE_GRAY = 1, // 1 component
        TYPE_BGRA8 = 4 // 4 components
    };
 
    uint16_t x, y;
    uint16_t width, height;
    uint32_t mask; // encode the region type, the face index and the component index in case of a gray region
 
    Type getType() const
    {
        return (Type)((mask >> 0) & 0x0000000F);
    }
 
    uint32_t getFaceIndex() const
    {
        return (mask >> 4) & 0x0000000F;
    }
 
    uint32_t getComponentIndex() const
    {
        return (mask >> 8) & 0x0000000F;
    }
 
    void setMask(Type _type, uint32_t _faceIndex, uint32_t _componentIndex)
    {
        mask = (_componentIndex << 8) + (_faceIndex << 4) + (uint32_t)_type;
    }
};
 
class Atlas
{
public:
    Atlas(uint16_t _textureSize, uint16_t _maxRegionsCount = 4096);
 
    Atlas(uint16_t _textureSize,
          const uint8_t* _textureBuffer,
          uint16_t _regionCount,
          const uint8_t* _regionBuffer,
          uint16_t _maxRegionsCount = 4096);
    ~Atlas();
 
    uint16_t addRegion(uint16_t _width,
                       uint16_t _height,
                       const uint8_t* _bitmapBuffer,
                       AtlasRegion::Type _type = AtlasRegion::TYPE_BGRA8,
                       uint16_t outline = 0);
 
    void updateRegion(const AtlasRegion& _region, const uint8_t* _bitmapBuffer);
 
    void packUV(uint16_t _regionHandle, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride) const;
    void packUV(const AtlasRegion& _region, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride) const;
 
    void packFaceLayerUV(uint32_t _idx, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride) const;
 
    bgfx::TextureHandle getTextureHandle() const
    {
        return m_textureHandle;
    }
 
    // retrieve a region info
    const AtlasRegion& getRegion(uint16_t _handle) const
    {
        return m_regions[_handle];
    }
 
    uint16_t getTextureSize() const
    {
        return m_textureSize;
    }
 
    // float getUsageRatio() const { return 0.0f; }
 
    uint16_t getRegionCount() const
    {
        return m_regionCount;
    }
 
    const AtlasRegion* getRegionBuffer() const
    {
        return m_regions;
    }
 
    uint32_t getTextureBufferSize() const
    {
        return 6 * m_textureSize * m_textureSize * 4;
    }
 
    const uint8_t* getTextureBuffer() const
    {
        return m_textureBuffer;
    }
 
private:
    struct PackedLayer;
    PackedLayer* m_layers;
    AtlasRegion* m_regions;
    uint8_t* m_textureBuffer;
 
    uint32_t m_usedLayers;
    uint32_t m_usedFaces;
 
    bgfx::TextureHandle m_textureHandle;
    uint16_t m_textureSize;
    float m_texelSize;
 
    uint16_t m_regionCount;
    uint16_t m_maxRegionCount;
};
 
}
#endif // CUBE_ATLAS_H_HEADER_GUARD