mirror of
https://github.com/scratchfoundation/bgfx.git
synced 2024-11-25 00:58:30 -05:00
483 lines
No EOL
13 KiB
C++
483 lines
No EOL
13 KiB
C++
/* Copyright 2013 Jeremie Roy. All rights reserved.
|
|
* License: http://www.opensource.org/licenses/BSD-2-Clause
|
|
*/
|
|
#pragma once
|
|
#include <bgfx.h>
|
|
#include <assert.h>
|
|
#include <vector>
|
|
#include "cube_atlas.h"
|
|
|
|
namespace bgfx
|
|
{
|
|
|
|
//********** Rectangle packer implementation ************
|
|
class RectanglePacker
|
|
{
|
|
public:
|
|
RectanglePacker();
|
|
RectanglePacker(uint32_t width, uint32_t height);
|
|
|
|
/// non constructor initialization
|
|
void init(uint32_t width, uint32_t height);
|
|
/// find a suitable position for the given rectangle
|
|
/// @return true if the rectangle can be added, false otherwise
|
|
bool addRectangle(uint16_t width, uint16_t height, uint16_t& outX, uint16_t& outY );
|
|
/// return the used surface in squared unit
|
|
uint32_t getUsedSurface() { return m_usedSpace; }
|
|
/// return the total available surface in squared unit
|
|
uint32_t getTotalSurface() { return m_width*m_height; }
|
|
/// return the usage ratio of the available surface [0:1]
|
|
float getUsageRatio();
|
|
/// reset to initial state
|
|
void clear();
|
|
|
|
private:
|
|
int32_t fit(uint32_t skylineNodeIndex, uint16_t width, uint16_t height);
|
|
/// Merges all skyline nodes that are at the same level.
|
|
void merge();
|
|
|
|
struct Node
|
|
{
|
|
Node(int16_t _x, int16_t _y, int16_t _width):x(_x), y(_y), width(_width) {}
|
|
|
|
/// The starting x-coordinate (leftmost).
|
|
int16_t x;
|
|
/// The y-coordinate of the skyline level line.
|
|
int16_t y;
|
|
/// The line width. The ending coordinate (inclusive) will be x+width-1.
|
|
int32_t width; //32bit to avoid padding
|
|
};
|
|
|
|
/// Width (in pixels) of the underlying texture
|
|
uint32_t m_width;
|
|
/// Height (in pixels) of the underlying texture
|
|
uint32_t m_height;
|
|
/// Surface used in squared pixel
|
|
uint32_t m_usedSpace;
|
|
/// node of the skyline algorithm
|
|
std::vector<Node> m_skyline;
|
|
};
|
|
|
|
RectanglePacker::RectanglePacker(): m_width(0), m_height(0), m_usedSpace(0)
|
|
{
|
|
}
|
|
|
|
RectanglePacker::RectanglePacker(uint32_t width, uint32_t height):m_width(width), m_height(height), m_usedSpace(0)
|
|
{
|
|
// We want a one pixel border around the whole atlas to avoid any artefact when
|
|
// sampling texture
|
|
m_skyline.push_back(Node(1,1, width-2));
|
|
}
|
|
|
|
void RectanglePacker::init(uint32_t width, uint32_t height)
|
|
{
|
|
assert(width > 2);
|
|
assert(height > 2);
|
|
m_width = width;
|
|
m_height = height;
|
|
m_usedSpace = 0;
|
|
|
|
m_skyline.clear();
|
|
// We want a one pixel border around the whole atlas to avoid any artifact when
|
|
// sampling texture
|
|
m_skyline.push_back(Node(1,1, width-2));
|
|
}
|
|
|
|
bool RectanglePacker::addRectangle(uint16_t width, uint16_t height, uint16_t& outX, uint16_t& outY)
|
|
{
|
|
int y, best_height, best_index;
|
|
int32_t best_width;
|
|
Node* node;
|
|
Node* prev;
|
|
outX = 0;
|
|
outY = 0;
|
|
|
|
size_t i;
|
|
|
|
best_height = INT_MAX;
|
|
best_index = -1;
|
|
best_width = INT_MAX;
|
|
for( i = 0; i < m_skyline.size(); ++i )
|
|
{
|
|
y = fit( i, width, height );
|
|
if( y >= 0 )
|
|
{
|
|
node = &m_skyline[i];
|
|
if( ( (y + height) < best_height ) ||
|
|
( ((y + height) == best_height) && (node->width < best_width)) )
|
|
{
|
|
best_height = y + height;
|
|
best_index = i;
|
|
best_width = node->width;
|
|
outX = node->x;
|
|
outY = y;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( best_index == -1 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Node newNode(outX,outY + height, width);
|
|
m_skyline.insert(m_skyline.begin() + best_index, newNode);
|
|
|
|
for(i = best_index+1; i < m_skyline.size(); ++i)
|
|
{
|
|
node = &m_skyline[i];
|
|
prev = &m_skyline[i-1];
|
|
if (node->x < (prev->x + prev->width) )
|
|
{
|
|
int shrink = prev->x + prev->width - node->x;
|
|
node->x += shrink;
|
|
node->width -= shrink;
|
|
if (node->width <= 0)
|
|
{
|
|
m_skyline.erase(m_skyline.begin() + i);
|
|
--i;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
merge();
|
|
m_usedSpace += width * height;
|
|
return true;
|
|
}
|
|
|
|
float RectanglePacker::getUsageRatio()
|
|
{
|
|
uint32_t total = m_width*m_height;
|
|
if(total > 0)
|
|
return (float) m_usedSpace / (float) total;
|
|
else
|
|
return 0.0f;
|
|
}
|
|
|
|
void RectanglePacker::clear()
|
|
{
|
|
m_skyline.clear();
|
|
m_usedSpace = 0;
|
|
|
|
// We want a one pixel border around the whole atlas to avoid any artefact when
|
|
// sampling texture
|
|
m_skyline.push_back(Node(1,1, m_width-2));
|
|
}
|
|
|
|
int32_t RectanglePacker::fit(uint32_t skylineNodeIndex, uint16_t _width, uint16_t _height)
|
|
{
|
|
int32_t width = _width;
|
|
int32_t height = _height;
|
|
|
|
const Node& baseNode = m_skyline[skylineNodeIndex];
|
|
|
|
int32_t x = baseNode.x, y;
|
|
int32_t width_left = width;
|
|
int32_t i = skylineNodeIndex;
|
|
|
|
if ( (x + width) > (int32_t)(m_width-1) )
|
|
{
|
|
return -1;
|
|
}
|
|
y = baseNode.y;
|
|
while( width_left > 0 )
|
|
{
|
|
const Node& node = m_skyline[i];
|
|
if( node.y > y )
|
|
{
|
|
y = node.y;
|
|
}
|
|
if( (y + height) > (int32_t)(m_height-1) )
|
|
{
|
|
return -1;
|
|
}
|
|
width_left -= node.width;
|
|
++i;
|
|
}
|
|
return y;
|
|
}
|
|
|
|
void RectanglePacker::merge()
|
|
{
|
|
Node* node;
|
|
Node* next;
|
|
uint32_t i;
|
|
|
|
for( i=0; i < m_skyline.size()-1; ++i )
|
|
{
|
|
node = (Node *) &m_skyline[i];
|
|
next = (Node *) &m_skyline[i+1];
|
|
if( node->y == next->y )
|
|
{
|
|
node->width += next->width;
|
|
m_skyline.erase(m_skyline.begin() + i + 1);
|
|
--i;
|
|
}
|
|
}
|
|
}
|
|
|
|
//********** Cube Atlas implementation ************
|
|
|
|
struct Atlas::PackedLayer
|
|
{
|
|
RectanglePacker packer;
|
|
AtlasRegion faceRegion;
|
|
};
|
|
|
|
Atlas::Atlas(uint16_t textureSize, uint16_t maxRegionsCount )
|
|
{
|
|
assert(textureSize >= 64 && textureSize <= 4096 && "suspicious texture size" );
|
|
assert(maxRegionsCount >= 64 && maxRegionsCount <= 32000 && "suspicious regions count" );
|
|
m_layers = new PackedLayer[24];
|
|
for(int i=0; i<24;++i)
|
|
{
|
|
m_layers[i].packer.init(textureSize, textureSize);
|
|
}
|
|
m_usedLayers = 0;
|
|
m_usedFaces = 0;
|
|
|
|
m_textureSize = textureSize;
|
|
m_regionCount = 0;
|
|
m_maxRegionCount = maxRegionsCount;
|
|
m_regions = new AtlasRegion[maxRegionsCount];
|
|
m_textureBuffer = new uint8_t[ textureSize * textureSize * 6 * 4 ];
|
|
memset(m_textureBuffer, 0, textureSize * textureSize * 6 * 4);
|
|
//BGFX_TEXTURE_MIN_POINT|BGFX_TEXTURE_MAG_POINT|BGFX_TEXTURE_MIP_POINT;
|
|
//BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT
|
|
//BGFX_TEXTURE_U_CLAMP|BGFX_TEXTURE_V_CLAMP
|
|
uint32_t flags = 0;// BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT;
|
|
|
|
//Uncomment this to debug atlas
|
|
//const bgfx::Memory* mem = bgfx::alloc(textureSize*textureSize * 6 * 4);
|
|
//memset(mem->data, 255, mem->size);
|
|
const bgfx::Memory* mem = NULL;
|
|
m_textureHandle = bgfx::createTextureCube(6
|
|
, textureSize
|
|
, 1
|
|
, bgfx::TextureFormat::BGRA8
|
|
, flags
|
|
,mem
|
|
);
|
|
}
|
|
|
|
Atlas::Atlas(uint16_t textureSize, const uint8_t* textureBuffer , uint16_t regionCount, const uint8_t* regionBuffer, uint16_t maxRegionsCount)
|
|
{
|
|
assert(regionCount <= 64 && maxRegionsCount <= 4096);
|
|
//layers are frozen
|
|
m_usedLayers = 24;
|
|
m_usedFaces = 6;
|
|
|
|
m_textureSize = textureSize;
|
|
m_regionCount = regionCount;
|
|
//regions are frozen
|
|
m_maxRegionCount = regionCount;
|
|
m_regions = new AtlasRegion[regionCount];
|
|
m_textureBuffer = new uint8_t[getTextureBufferSize()];
|
|
|
|
//BGFX_TEXTURE_MIN_POINT|BGFX_TEXTURE_MAG_POINT|BGFX_TEXTURE_MIP_POINT;
|
|
//BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT
|
|
//BGFX_TEXTURE_U_CLAMP|BGFX_TEXTURE_V_CLAMP
|
|
uint32_t flags = 0;//BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT;
|
|
memcpy(m_regions, regionBuffer, regionCount * sizeof(AtlasRegion));
|
|
memcpy(m_textureBuffer, textureBuffer, getTextureBufferSize());
|
|
|
|
m_textureHandle = bgfx::createTextureCube(6
|
|
, textureSize
|
|
, 1
|
|
, bgfx::TextureFormat::BGRA8
|
|
, flags
|
|
, bgfx::makeRef(m_textureBuffer, getTextureBufferSize())
|
|
);
|
|
}
|
|
|
|
Atlas::~Atlas()
|
|
{
|
|
delete[] m_layers;
|
|
delete[] m_regions;
|
|
delete[] m_textureBuffer;
|
|
}
|
|
|
|
uint16_t Atlas::addRegion(uint16_t width, uint16_t height, const uint8_t* bitmapBuffer, AtlasRegion::Type type)
|
|
{
|
|
if (m_regionCount >= m_maxRegionCount)
|
|
{
|
|
return UINT16_MAX;
|
|
}
|
|
|
|
uint16_t x,y;
|
|
// We want each bitmap to be separated by at least one black pixel
|
|
// TODO manage mipmaps
|
|
uint32_t idx = 0;
|
|
while(idx<m_usedLayers)
|
|
{
|
|
if(m_layers[idx].faceRegion.getType() == type)
|
|
{
|
|
if(m_layers[idx].packer.addRectangle(width+1,height+1,x,y)) break;
|
|
}
|
|
idx++;
|
|
}
|
|
|
|
if(idx >= m_usedLayers)
|
|
{
|
|
//do we have still room to add layers ?
|
|
if( (idx + type) > 24 || m_usedFaces>=6)
|
|
{
|
|
return UINT16_MAX;
|
|
}
|
|
//create new layers
|
|
for(int i=0; i < type;++i)
|
|
{
|
|
m_layers[idx+i].faceRegion.setMask(type, m_usedFaces, i);
|
|
}
|
|
m_usedLayers += type;
|
|
m_usedFaces++;
|
|
|
|
|
|
//add it to the created layer
|
|
if(!m_layers[idx].packer.addRectangle(width+1,height+1,x,y))
|
|
{
|
|
return UINT16_MAX;
|
|
}
|
|
}
|
|
|
|
AtlasRegion& region = m_regions[m_regionCount];
|
|
region.x = x;
|
|
region.y = y;
|
|
region.width = width;
|
|
region.height = height;
|
|
region.mask = m_layers[idx].faceRegion.mask;
|
|
|
|
updateRegion(region, bitmapBuffer);
|
|
return m_regionCount++;
|
|
}
|
|
|
|
void Atlas::updateRegion(const AtlasRegion& region, const uint8_t* bitmapBuffer)
|
|
{
|
|
const bgfx::Memory* mem = bgfx::alloc(region.width * region.height * 4);
|
|
//BAD!
|
|
memset(mem->data,0, mem->size);
|
|
if(region.getType() == AtlasRegion::TYPE_BGRA8)
|
|
{
|
|
const uint8_t* inLineBuffer = bitmapBuffer;
|
|
uint8_t* outLineBuffer = m_textureBuffer + region.getFaceIndex() * (m_textureSize*m_textureSize*4) + (((region.y *m_textureSize)+region.x)*4);
|
|
|
|
//update the cpu buffer
|
|
for(int y = 0; y < region.height; ++y)
|
|
{
|
|
memcpy(outLineBuffer, inLineBuffer, region.width * 4);
|
|
inLineBuffer += region.width*4;
|
|
outLineBuffer += m_textureSize*4;
|
|
}
|
|
//update the GPU buffer
|
|
memcpy(mem->data, bitmapBuffer, mem->size);
|
|
}else
|
|
{
|
|
uint32_t layer = region.getComponentIndex();
|
|
uint32_t face = region.getFaceIndex();
|
|
const uint8_t* inLineBuffer = bitmapBuffer;
|
|
uint8_t* outLineBuffer = (m_textureBuffer + region.getFaceIndex() * (m_textureSize*m_textureSize*4) + (((region.y *m_textureSize)+region.x)*4));
|
|
|
|
//update the cpu buffer
|
|
for(int y = 0; y<region.height; ++y)
|
|
{
|
|
for(int x = 0; x<region.width; ++x)
|
|
{
|
|
outLineBuffer[(x*4) + layer] = inLineBuffer[x];
|
|
}
|
|
//update the GPU buffer
|
|
memcpy(mem->data + y*region.width*4, outLineBuffer, region.width*4);
|
|
inLineBuffer += region.width;
|
|
outLineBuffer += m_textureSize*4;
|
|
}
|
|
}
|
|
bgfx::updateTextureCube(m_textureHandle, (uint8_t)region.getFaceIndex(), 0, region.x, region.y, region.width, region.height, mem);
|
|
}
|
|
|
|
void Atlas::packFaceLayerUV(uint32_t idx, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride )
|
|
{
|
|
packUV(m_layers[idx].faceRegion, vertexBuffer, offset, stride);
|
|
}
|
|
|
|
void Atlas::packUV( uint16_t handle, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride )
|
|
{
|
|
const AtlasRegion& region = m_regions[handle];
|
|
packUV(region, vertexBuffer, offset, stride);
|
|
}
|
|
|
|
void Atlas::packUV( const AtlasRegion& region, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride )
|
|
{
|
|
float texMult = 65535.0f / ((float)(m_textureSize));
|
|
static const int16_t minVal = -32768;
|
|
static const int16_t maxVal = 32767;
|
|
|
|
int16_t x0 = (int16_t)(region.x * texMult)-32768;
|
|
int16_t y0 = (int16_t)(region.y * texMult)-32768;
|
|
int16_t x1 = (int16_t)((region.x + region.width)* texMult)-32768;
|
|
int16_t y1 = (int16_t)((region.y + region.height)* texMult)-32768;
|
|
int16_t w = (int16_t) ((32767.0f/4.0f) * region.getComponentIndex());
|
|
|
|
vertexBuffer+=offset;
|
|
switch(region.getFaceIndex())
|
|
{
|
|
case 0: // +X
|
|
x0= -x0;
|
|
x1= -x1;
|
|
y0= -y0;
|
|
y1= -y1;
|
|
writeUV(vertexBuffer, maxVal, y0, x0, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, maxVal, y1, x0, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, maxVal, y1, x1, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, maxVal, y0, x1, w); vertexBuffer+=stride;
|
|
break;
|
|
case 1: // -X
|
|
y0= -y0;
|
|
y1= -y1;
|
|
writeUV(vertexBuffer, minVal, y0, x0, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, minVal, y1, x0, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, minVal, y1, x1, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, minVal, y0, x1, w); vertexBuffer+=stride;
|
|
break;
|
|
case 2: // +Y
|
|
writeUV(vertexBuffer, x0, maxVal, y0, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x0, maxVal, y1, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, maxVal, y1, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, maxVal, y0, w); vertexBuffer+=stride;
|
|
break;
|
|
case 3: // -Y
|
|
y0= -y0;
|
|
y1= -y1;
|
|
writeUV(vertexBuffer, x0, minVal, y0, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x0, minVal, y1, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, minVal, y1, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, minVal, y0, w); vertexBuffer+=stride;
|
|
break;
|
|
case 4: // +Z
|
|
y0= -y0;
|
|
y1= -y1;
|
|
writeUV(vertexBuffer, x0, y0, maxVal, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x0, y1, maxVal, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, y1, maxVal, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, y0, maxVal, w); vertexBuffer+=stride;
|
|
break;
|
|
case 5: // -Z
|
|
x0= -x0;
|
|
x1= -x1;
|
|
y0= -y0;
|
|
y1= -y1;
|
|
writeUV(vertexBuffer, x0, y0, minVal, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x0, y1, minVal, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, y1, minVal, w); vertexBuffer+=stride;
|
|
writeUV(vertexBuffer, x1, y0, minVal, w); vertexBuffer+=stride;
|
|
break;
|
|
}
|
|
}
|
|
|
|
} |