// EXTERNAL INCLUDE
#include <iostream>
#include <string.h>
+#include <dali/devel-api/rendering/sampler.h>
+#include <dali/devel-api/rendering/shader.h>
#include <dali/integration-api/debug.h>
namespace Dali
namespace
{
- const Vector2 DEFAULT_ATLAS_SIZE( 512.0f, 512.0f );
- const Vector2 DEFAULT_BLOCK_SIZE( 32.0f, 32.0f );
+ const uint32_t DEFAULT_ATLAS_WIDTH( 512u );
+ const uint32_t DEFAULT_ATLAS_HEIGHT( 512u );
+ const uint32_t DEFAULT_BLOCK_WIDTH( 16u );
+ const uint32_t DEFAULT_BLOCK_HEIGHT( 16u );
const uint32_t SINGLE_PIXEL_PADDING( 1u );
const uint32_t DOUBLE_PIXEL_PADDING( SINGLE_PIXEL_PADDING << 1 );
const uint32_t FILLED_PIXEL( -1 );
+ Toolkit::AtlasManager::AtlasSize EMPTY_SIZE;
+
+ #define MAKE_SHADER(A)#A
+
+ const char* VERTEX_SHADER = MAKE_SHADER(
+ attribute mediump vec2 aPosition;
+ attribute mediump vec2 aTexCoord;
+ uniform mediump mat4 uMvpMatrix;
+ uniform mediump vec3 uSize;
+ varying mediump vec2 vTexCoord;
+
+ void main()
+ {
+ mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
+ position.xyz *= uSize;
+ gl_Position = uMvpMatrix * position;
+ vTexCoord = aTexCoord;
+ }
+ );
+
+ const char* FRAGMENT_SHADER_L8 = MAKE_SHADER(
+ uniform lowp vec4 uColor;
+ uniform sampler2D sTexture;
+ varying mediump vec2 vTexCoord;
+
+ void main()
+ {
+ mediump vec4 color = texture2D( sTexture, vTexCoord );
+ gl_FragColor = vec4( uColor.rgb, uColor.a * color.r );
+ }
+ );
+
+ const char* FRAGMENT_SHADER_RGBA = MAKE_SHADER(
+ uniform sampler2D sTexture;
+ varying mediump vec2 vTexCoord;
+
+ void main()
+ {
+ gl_FragColor = texture2D( sTexture, vTexCoord );
+ }
+ );
+
}
AtlasManager::AtlasManager()
-: mNewAtlasSize( DEFAULT_ATLAS_SIZE ),
- mNewBlockSize( DEFAULT_BLOCK_SIZE ),
- mAddFailPolicy( Toolkit::AtlasManager::FAIL_ON_ADD_CREATES ),
+: mAddFailPolicy( Toolkit::AtlasManager::FAIL_ON_ADD_CREATES ),
mFilledPixel( FILLED_PIXEL )
{
+ mNewAtlasSize.mWidth = DEFAULT_ATLAS_WIDTH;
+ mNewAtlasSize.mHeight = DEFAULT_ATLAS_HEIGHT;
+ mNewAtlasSize.mBlockWidth = DEFAULT_BLOCK_WIDTH;
+ mNewAtlasSize.mBlockHeight = DEFAULT_BLOCK_HEIGHT;
+ mShaderL8 = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_L8 );
+ mShaderRgba = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_RGBA );
}
AtlasManagerPtr AtlasManager::New()
AtlasManager::~AtlasManager()
{
- for ( uint32_t i = 0; i < mAtlasList.size(); ++i )
+ for ( SizeType i = 0; i < mAtlasList.size(); ++i )
{
+ mAtlasList[ i ].mAtlas.UploadedSignal().Disconnect( this, &AtlasManager::OnUpload );
delete[] mAtlasList[ i ].mStripBuffer;
}
+
+ // Are there any upload signals pending? Free up those buffer images now.
+ for ( SizeType i = 0; i < mUploadedImages.Size(); ++i )
+ {
+ delete[] mUploadedImages[ i ];
+ }
}
-Toolkit::AtlasManager::AtlasId AtlasManager::CreateAtlas( SizeType width,
- SizeType height,
- SizeType blockWidth,
- SizeType blockHeight,
- Pixel::Format pixelformat )
+void AtlasManager::OnUpload( Image image )
{
+ if ( mUploadedImages.Size() )
+ {
+ delete[] mUploadedImages[ 0 ];
+ mUploadedImages.Erase( mUploadedImages.Begin() );
+ }
+ else
+ {
+ DALI_LOG_ERROR("Atlas Image Upload List should not be empty\n");
+ }
+}
+
+Toolkit::AtlasManager::AtlasId AtlasManager::CreateAtlas( const Toolkit::AtlasManager::AtlasSize& size, Pixel::Format pixelformat )
+{
+ SizeType width = size.mWidth;
+ SizeType height = size.mHeight;
+ SizeType blockWidth = size.mBlockWidth;
+ SizeType blockHeight = size.mBlockHeight;
+
// Check to see if the atlas is large enough to hold a single block even ?
if ( blockWidth > width || blockHeight > height )
{
Dali::Atlas atlas = Dali::Atlas::New( width, height, pixelformat );
AtlasDescriptor atlasDescriptor;
atlasDescriptor.mAtlas = atlas;
- atlasDescriptor.mWidth = width;
- atlasDescriptor.mHeight = height;
- atlasDescriptor.mBlockWidth = blockWidth;
- atlasDescriptor.mBlockHeight = blockHeight;
+ atlasDescriptor.mSize = size;
atlasDescriptor.mPixelFormat = pixelformat;
- std::stringstream materialLabel;
- materialLabel << "Atlas Material - ";
- materialLabel << mAtlasList.size();
- atlasDescriptor.mMaterial = Material::New( materialLabel.str() );
- atlasDescriptor.mMaterial.SetDiffuseTexture( atlas );
atlasDescriptor.mNextFreeBlock = 1u; // indicate next free block will be the first ( +1 )
+ atlas.UploadedSignal().Connect( this, &AtlasManager::OnUpload );
// What size do we need for this atlas' strip buffer ( assume 32bit pixel format )?
- uint32_t neededStripSize =( blockWidth > blockHeight - DOUBLE_PIXEL_PADDING ? blockWidth : blockHeight - DOUBLE_PIXEL_PADDING ) << 2;
+ SizeType neededStripSize =( blockWidth > blockHeight - DOUBLE_PIXEL_PADDING ? blockWidth : blockHeight - DOUBLE_PIXEL_PADDING ) << 2;
atlasDescriptor.mStripBuffer = new PixelBuffer[ neededStripSize ];
memset( atlasDescriptor.mStripBuffer, 0, neededStripSize );
SINGLE_PIXEL_PADDING,
blockHeight - DOUBLE_PIXEL_PADDING,
pixelformat );
+ mUploadedImages.PushBack( NULL );
atlasDescriptor.mFilledPixelImage = BufferImage::New( reinterpret_cast< PixelBuffer* >( &mFilledPixel ), 1, 1, pixelformat );
atlas.Upload( atlasDescriptor.mFilledPixelImage, 0, 0 );
+
+ Sampler sampler = Sampler::New( atlas, "sTexture" );
+ sampler.SetProperty( Sampler::Property::AFFECTS_TRANSPARENCY, true );
+ atlasDescriptor.mMaterial = Material::New( pixelformat == Pixel::L8 ? mShaderL8 : mShaderRgba );
+ atlasDescriptor.mMaterial.AddSampler( sampler );
+ atlasDescriptor.mSampler = sampler;
+ atlasDescriptor.mMaterial.SetBlendMode( BlendingMode::ON );
mAtlasList.push_back( atlasDescriptor );
return mAtlasList.size();
}
{
if ( Toolkit::AtlasManager::FAIL_ON_ADD_CREATES == mAddFailPolicy )
{
- SizeType newAtlas = CreateAtlas( mNewAtlasSize.x, mNewAtlasSize.y, mNewBlockSize.x, mNewBlockSize.y, pixelFormat );
+ SizeType newAtlas = CreateAtlas( mNewAtlasSize, pixelFormat );
if ( !newAtlas-- )
{
return;
if ( Toolkit::AtlasManager::FAIL_ON_ADD_FAILS == mAddFailPolicy || !foundAtlas-- )
{
// Haven't found an atlas for this image!!!!!!
- return;
+ return;
}
}
if ( pixelFormat == mAtlasList[ atlas ].mPixelFormat )
{
// Check to see if there are any unused blocks in this atlas to accomodate our image
- SizeType blocksInX = mAtlasList[ atlas ].mWidth / mAtlasList[ atlas ].mBlockWidth;
- SizeType blocksInY = mAtlasList[ atlas ].mHeight / mAtlasList[ atlas ].mBlockHeight;
+ SizeType blocksInX = mAtlasList[ atlas ].mSize.mWidth / mAtlasList[ atlas ].mSize.mBlockWidth;
+ SizeType blocksInY = mAtlasList[ atlas ].mSize.mHeight / mAtlasList[ atlas ].mSize.mBlockHeight;
totalBlocks = blocksInX * blocksInY;
SizeType blocksFree = mAtlasList[ atlas ].mNextFreeBlock ?
totalBlocks - mAtlasList[ atlas ].mNextFreeBlock + 1u :
// Check to see if the image will fit in these blocks, if not we'll need to create a new atlas
if ( blocksFree
- && width + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mBlockWidth
- && height + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mBlockHeight )
+ && width + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mSize.mBlockWidth
+ && height + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mSize.mBlockHeight )
{
blockArea = 1u;
return ( atlas + 1u );
const Vector2& position,
SizeType widthInBlocks,
SizeType heightInBlocks,
- Dali::MeshData& meshData,
+ Toolkit::AtlasManager::Mesh2D& mesh,
AtlasSlotDescriptor& desc )
{
- Dali::MeshData::Vertex vertex;
- Dali::MeshData::VertexContainer vertices;
- Dali::MeshData::FaceIndices faces;
- Dali::MeshData::FaceIndex faceIndex = 0;
- meshData.SetHasNormals( false );
- meshData.SetHasColor( true );
- meshData.SetHasTextureCoords( true );
- SizeType blockWidth = mAtlasList[ atlas ].mBlockWidth;
- SizeType blockHeight = mAtlasList[ atlas ].mBlockHeight;
+ Toolkit::AtlasManager::Vertex2D vertex;
+ uint32_t faceIndex = 0; // TODO change to unsigned short when property type is available
+
+ SizeType blockWidth = mAtlasList[ atlas ].mSize.mBlockWidth;
+ SizeType blockHeight = mAtlasList[ atlas ].mSize.mBlockHeight;
float vertexBlockWidth = static_cast< float >( blockWidth );
float vertexBlockHeight = static_cast< float >( blockHeight );
- SizeType width = mAtlasList[ atlas ].mWidth;
- SizeType height = mAtlasList[ atlas ].mHeight;
+ SizeType width = mAtlasList[ atlas ].mSize.mWidth;
+ SizeType height = mAtlasList[ atlas ].mSize.mHeight;
SizeType atlasWidthInBlocks = width / blockWidth;
}
// Top left
- vertex.x = topLeft.x;
- vertex.y = topLeft.y;
- vertex.z = 0.0f;
- vertex.u = fBlockX;
- vertex.v = fBlockY;
+ vertex.mPosition.x = topLeft.x;
+ vertex.mPosition.y = topLeft.y;
+ vertex.mTexCoords.x = fBlockX;
+ vertex.mTexCoords.y = fBlockY;
- vertices.push_back( vertex );
+ mesh.mVertices.PushBack( vertex );
// Top Right
- vertex.x = topLeft.x + ndcVWidth;
- vertex.y = topLeft.y;
- vertex.z = 0.0f;
- vertex.u = fBlockX + ndcWidth;
- vertex.v = fBlockY;
+ vertex.mPosition.x = topLeft.x + ndcVWidth;
+ vertex.mPosition.y = topLeft.y;
+ vertex.mTexCoords.x = fBlockX + ndcWidth;
+ vertex.mTexCoords.y = fBlockY;
- vertices.push_back( vertex );
+ mesh.mVertices.PushBack( vertex );
// Bottom Left
- vertex.x = topLeft.x;
- vertex.y = topLeft.y + ndcVHeight;
- vertex.z = 0.0f;
- vertex.u = fBlockX;
- vertex.v = fBlockY + ndcHeight;
+ vertex.mPosition.x = topLeft.x;
+ vertex.mPosition.y = topLeft.y + ndcVHeight;
+ vertex.mTexCoords.x = fBlockX;
+ vertex.mTexCoords.y = fBlockY + ndcHeight;
- vertices.push_back( vertex );
+ mesh.mVertices.PushBack( vertex );
// Bottom Right
topLeft.x += ndcVWidth;
- vertex.x = topLeft.x;
- vertex.y = topLeft.y + ndcVHeight;
- vertex.z = 0.0f;
- vertex.u = fBlockX + ndcWidth;
- vertex.v = fBlockY + ndcHeight;
+ vertex.mPosition.x = topLeft.x;
+ vertex.mPosition.y = topLeft.y + ndcVHeight;
+ vertex.mTexCoords.x = fBlockX + ndcWidth;
+ vertex.mTexCoords.y = fBlockY + ndcHeight;
- vertices.push_back( vertex );
+ mesh.mVertices.PushBack( vertex );
// Six indices in counter clockwise winding
- faces.push_back( faceIndex + 1u );
- faces.push_back( faceIndex );
- faces.push_back( faceIndex + 2u );
- faces.push_back( faceIndex + 2u );
- faces.push_back( faceIndex + 3u );
- faces.push_back( faceIndex + 1u );
+ mesh.mIndices.PushBack( faceIndex + 1u );
+ mesh.mIndices.PushBack( faceIndex );
+ mesh.mIndices.PushBack( faceIndex + 2u );
+ mesh.mIndices.PushBack( faceIndex + 2u );
+ mesh.mIndices.PushBack( faceIndex + 3u );
+ mesh.mIndices.PushBack( faceIndex + 1u );
faceIndex += 4;
}
// If there's only one block then skip this next vertex optimisation
if ( widthInBlocks * heightInBlocks > 1 )
{
- Dali::MeshData::VertexContainer optimizedVertices;
- OptimizeVertices( vertices, faces, optimizedVertices );
- meshData.SetVertices( optimizedVertices );
- }
- else
- {
- meshData.SetVertices( vertices );
+ Toolkit::AtlasManager::Mesh2D optimizedMesh;
+ OptimizeMesh( mesh, optimizedMesh );
}
-
- meshData.SetFaceIndices( faces );
- meshData.SetMaterial( mAtlasList[ atlas ].mMaterial );
+ //PrintMeshData( mesh );
}
-void AtlasManager::PrintMeshData( const MeshData& meshData )
+void AtlasManager::PrintMeshData( const Toolkit::AtlasManager::Mesh2D& mesh )
{
- std::cout << "\nMesh Data for Image: VertexCount = " << meshData.GetVertexCount();
- std::cout << ", Triangles = " << meshData.GetFaceCount() << std::endl;
-
- Dali::MeshData::VertexContainer vertices = meshData.GetVertices();
- Dali::MeshData::FaceIndices faces = meshData.GetFaces();
+ uint32_t vertexCount = mesh.mVertices.Size();
+ uint32_t indexCount = mesh.mIndices.Size();
+ std::cout << "\nMesh Data for Image: VertexCount = " << vertexCount;
+ std::cout << ", Triangles = " << indexCount / 3 << std::endl;
- for ( SizeType v = 0; v < vertices.size(); ++v )
+ for ( SizeType v = 0; v < vertexCount; ++v )
{
- std::cout << " Vertex(" << v << ") x = " << vertices[v].x << ", ";
- std::cout << "y = " << vertices[v].y << ", " << "z = " << vertices[v].z << ", ";
- std::cout << "u = " << vertices[v].u << ", " << "v = " << vertices[v].v << std::endl;
+ std::cout << " Vertex(" << v << ") x = " << mesh.mVertices[v].mPosition.x << ", ";
+ std::cout << "y = " << mesh.mVertices[v].mPosition.y << ", ";
+ std::cout << "u = " << mesh.mVertices[v].mTexCoords.x << ", ";
+ std::cout << "v = " << mesh.mVertices[v].mTexCoords.y << std::endl;
}
std::cout << "\n Indices: ";
- for ( SizeType i = 0; i < faces.size(); ++i )
+ for ( SizeType i = 0; i < indexCount; ++i )
{
- std::cout << " " << faces[ i ];
+ std::cout << " " << mesh.mIndices[ i ];
}
std::cout << std::endl;
}
-void AtlasManager::OptimizeVertices( const MeshData::VertexContainer& in,
- MeshData::FaceIndices& faces,
- MeshData::VertexContainer& out )
+void AtlasManager::OptimizeMesh( const Toolkit::AtlasManager::Mesh2D& in,
+ Toolkit::AtlasManager::Mesh2D& out )
{
unsigned short vertexIndex = 0;
// We could check to see if blocks are next to each other, but it's probably just as quick to compare verts
- for ( SizeType i = 0; i < faces.size(); ++i )
+ for ( SizeType i = 0; i < in.mIndices.Size(); ++i )
{
// Fetch a vertex, has it already been assigned?
bool foundVertex = false;
- Dali::MeshData::Vertex v = in[ faces [ i ] ];
- for ( SizeType j = 0; j < vertexIndex; ++j )
+ Toolkit::AtlasManager::Vertex2D v = in.mVertices[ in.mIndices[ i ] ];
+ for ( SizeType j = 0; j < out.mVertices.Size(); ++j )
{
- if ( v.x == out[ j ].x && v.y == out[ j ].y && v.z == out[ j ].z &&
- v.u == out[ j ].u && v.v == out[ j ].v && v.nX == out[ j ].nX &&
- v.nY == out[ j ].nY && v.nZ == out[ j ].nZ )
+ if ( v.mPosition.x == out.mVertices[ j ].mPosition.x && v.mPosition.y == out.mVertices[ j ].mPosition.y &&
+ v.mTexCoords.x == out.mVertices[ j ].mTexCoords.x && v.mTexCoords.y == out.mVertices[ j ].mTexCoords.y )
{
// Yes, so store this down as the vertex to use
- faces[ i ] = j;
+ out.mIndices.PushBack( j );
foundVertex = true;
break;
}
// Did we find a vertex ?
if ( !foundVertex )
{
- // Add a new vertex
- faces[ i ] = vertexIndex++;
- out.push_back( v );
+ // No so add a new one
+ out.mVertices.PushBack( v );
+ vertexIndex++;
}
}
}
-void AtlasManager::StitchMesh( MeshData& first,
- const MeshData& second,
+void AtlasManager::StitchMesh( Toolkit::AtlasManager::Mesh2D& first,
+ const Toolkit::AtlasManager::Mesh2D& second,
bool optimize )
{
+ uint32_t vc = first.mVertices.Size();
- // Would be much quicker to be able to get a non-const reference to these containers and update in situ
- MeshData::VertexContainer v1 = first.GetVertices();
- MeshData::VertexContainer v2 = second.GetVertices();
- MeshData::FaceIndices f1 = first.GetFaces();
- MeshData::FaceIndices f2 = second.GetFaces();
-
- uint32_t vc1 = first.GetVertexCount();
- uint32_t vc2 = second.GetVertexCount();
-
- for ( uint32_t v = 0; v < vc2; ++v )
+ for ( uint32_t v = 0; v < second.mVertices.Size(); ++v )
{
- v1.push_back( v2[ v ] );
+ first.mVertices.PushBack( second.mVertices[ v ] );
}
- for ( uint32_t f = 0; f < f2.size(); ++f )
+ for ( uint32_t i = 0; i < second.mIndices.Size(); ++i )
{
- f1.push_back( f2[ f ] + vc1 );
+ first.mIndices.PushBack( second.mIndices[ i ] + vc );
}
if ( optimize )
{
- MeshData::VertexContainer optimizedVertices;
- OptimizeVertices( v1, f1, optimizedVertices );
- first.SetVertices( optimizedVertices );
+ Toolkit::AtlasManager::Mesh2D optimizedMesh;
+ OptimizeMesh( first, optimizedMesh );
+ first = optimizedMesh;
}
- else
- {
- first.SetVertices( v1 );
- }
-
- first.SetFaceIndices( f1 );
}
-void AtlasManager::StitchMesh( const MeshData& first,
- const MeshData& second,
- MeshData& out,
+void AtlasManager::StitchMesh( const Toolkit::AtlasManager::Mesh2D& first,
+ const Toolkit::AtlasManager::Mesh2D& second,
+ Toolkit::AtlasManager::Mesh2D& out,
bool optimize )
{
- MeshData::VertexContainer v1 = first.GetVertices();
- MeshData::VertexContainer v2 = second.GetVertices();
- MeshData::FaceIndices f1 = first.GetFaces();
- MeshData::FaceIndices f2 = second.GetFaces();
-
- uint32_t vc1 = first.GetVertexCount();
- uint32_t vc2 = second.GetVertexCount();
-
- MeshData::VertexContainer vertices;
-
- MeshData::FaceIndices faces;
+ uint32_t vc = first.mVertices.Size();
- MeshData::Vertex vertex;
-
- for ( uint32_t v = 0; v < vc1; ++v )
+ for ( uint32_t v = 0; v < vc; ++v )
{
- vertices.push_back( v1[ v ] );
+ out.mVertices.PushBack( first.mVertices[ v ] );
}
- for ( uint32_t v = 0; v < vc2; ++v )
+ for ( uint32_t v = 0; v < second.mVertices.Size(); ++v )
{
- vertices.push_back( v2[ v ] );
+ out.mVertices.PushBack( second.mVertices[ v ] );
}
- for ( uint32_t f = 0; f < f1.size(); ++f )
+ for ( uint32_t i = 0; i < first.mIndices.Size(); ++i )
{
- faces.push_back( f1[ f ] );
+ out.mIndices.PushBack( first.mIndices[ i ] );
}
- for ( uint32_t f = 0; f < f2.size(); ++f )
+ for ( uint32_t i = 0; i < second.mIndices.Size(); ++i )
{
- faces.push_back( f2[ f ] + vc1 );
+ out.mIndices.PushBack( second.mIndices[ i ] + vc );
}
if ( optimize )
{
- MeshData::VertexContainer optimizedVertices;
- OptimizeVertices( vertices, faces, optimizedVertices );
- out.SetVertices( optimizedVertices );
+ Toolkit::AtlasManager::Mesh2D optimizedMesh;
+ OptimizeMesh( out, optimizedMesh );
+ out = optimizedMesh;
}
- else
- {
- out.SetVertices( vertices );
- }
-
- out.SetMaterial( first.GetMaterial() );
- out.SetFaceIndices( faces );
}
void AtlasManager::UploadImage( const BufferImage& image,
return;
}
- SizeType atlasBlockWidth = mAtlasList[ atlas ].mBlockWidth;
- SizeType atlasBlockHeight = mAtlasList[ atlas ].mBlockHeight;
- SizeType atlasWidthInBlocks = mAtlasList[ atlas ].mWidth / mAtlasList[ atlas ].mBlockWidth;
+ SizeType atlasBlockWidth = mAtlasList[ atlas ].mSize.mBlockWidth;
+ SizeType atlasBlockHeight = mAtlasList[ atlas ].mSize.mBlockHeight;
+ SizeType atlasWidthInBlocks = mAtlasList[ atlas ].mSize.mWidth / mAtlasList[ atlas ].mSize.mBlockWidth;
SizeType block = desc.mBlocksList[ 0 ];
SizeType blockX = block % atlasWidthInBlocks;
{
DALI_LOG_ERROR("Uploading image to Atlas Failed!.\n");
}
+ else
+ {
+ mUploadedImages.PushBack( const_cast< BufferImage& >( image ).GetBuffer() );
+ }
// If this is the first block then we need to keep the first pixel free for underline texture
if ( block )
{
DALI_LOG_ERROR("Uploading top strip to Atlas Failed!\n");
}
+ else
+ {
+ mUploadedImages.PushBack( NULL );
+ }
// Blit left strip
if ( !mAtlasList[ atlas ].mAtlas.Upload( mAtlasList[ atlas ].mVerticalStrip,
{
DALI_LOG_ERROR("Uploading left strip to Atlas Failed!\n");
}
+ else
+ {
+ mUploadedImages.PushBack( NULL );
+ }
}
// Blit bottom strip
- if ( blockOffsetY + height + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mHeight )
+ if ( blockOffsetY + height + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mSize.mHeight )
{
if ( !mAtlasList[ atlas ].mAtlas.Upload( mAtlasList[ atlas ].mHorizontalStrip,
blockOffsetX,
{
DALI_LOG_ERROR("Uploading bottom strip to Atlas Failed!.\n");
}
+ else
+ {
+ mUploadedImages.PushBack( NULL );
+ }
}
// Blit right strip
- if ( blockOffsetX + width + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mWidth )
+ if ( blockOffsetX + width + DOUBLE_PIXEL_PADDING <= mAtlasList[ atlas ].mSize.mWidth )
{
if ( !mAtlasList[ atlas ].mAtlas.Upload( mAtlasList[ atlas ].mVerticalStrip,
blockOffsetX + width + SINGLE_PIXEL_PADDING,
{
DALI_LOG_ERROR("Uploading right strip to Atlas Failed!.\n");
}
+ else
+ {
+ mUploadedImages.PushBack( NULL );
+ }
}
}
void AtlasManager::GenerateMeshData( ImageId id,
const Vector2& position,
- MeshData& meshData )
+ Toolkit::AtlasManager::Mesh2D& meshData,
+ bool addReference )
{
// Read the atlas Id to use for this image
SizeType imageId = id - 1u;
SizeType width = mImageList[ imageId ].mImageWidth;
SizeType height = mImageList[ imageId ].mImageHeight;
- SizeType widthInBlocks = width / mAtlasList[ atlas ].mBlockWidth;
- if ( width % mAtlasList[ atlas ].mBlockWidth )
+ SizeType widthInBlocks = width / mAtlasList[ atlas ].mSize.mBlockWidth;
+ if ( width % mAtlasList[ atlas ].mSize.mBlockWidth )
{
widthInBlocks++;
}
- SizeType heightInBlocks = height / mAtlasList[ atlas ].mBlockHeight;
- if ( height % mAtlasList[ atlas ].mBlockHeight )
+ SizeType heightInBlocks = height / mAtlasList[ atlas ].mSize.mBlockHeight;
+ if ( height % mAtlasList[ atlas ].mSize.mBlockHeight )
{
heightInBlocks++;
}
CreateMesh( atlas, width, height, position, widthInBlocks, heightInBlocks, meshData, mImageList[ imageId ] );
- // Mesh created so increase the reference count
- mImageList[ imageId ].mCount++;
+ // Mesh created so increase the reference count, if we're asked to
+ if ( addReference )
+ {
+ mImageList[ imageId ].mCount++;
+ }
}
Dali::Atlas AtlasManager::GetAtlasContainer( AtlasId atlas ) const
return false;
}
- if ( 1u == --mImageList[ imageId ].mCount )
+ if ( 2u > --mImageList[ imageId ].mCount )
{
// 'Remove the blocks' from this image and add to the atlas' freelist
removed = true;
}
}
-void AtlasManager::SetNewAtlasSize( const Vector2& size,
- const Vector2& blockSize )
+void AtlasManager::SetNewAtlasSize( const Toolkit::AtlasManager::AtlasSize& size )
{
mNewAtlasSize = size;
- mNewBlockSize = blockSize;
+ mNewAtlasSize.mBlockWidth += DOUBLE_PIXEL_PADDING;
+ mNewAtlasSize.mBlockHeight += DOUBLE_PIXEL_PADDING;
}
-Vector2 AtlasManager::GetBlockSize( AtlasId atlas )
+const Toolkit::AtlasManager::AtlasSize& AtlasManager::GetAtlasSize( AtlasId atlas )
{
- if ( atlas && atlas <= mAtlasList.size() )
+ if ( atlas && atlas-- <= mAtlasList.size() )
{
- return Vector2( static_cast< float >( mAtlasList[ atlas - 1u ].mBlockWidth ),
- static_cast< float >( mAtlasList[ atlas - 1u ].mBlockHeight) );
- }
- else
- {
- return Vector2::ZERO;
- }
-}
-
-Vector2 AtlasManager::GetAtlasSize( AtlasId atlas )
-{
- if ( atlas && atlas <= mAtlasList.size() )
- {
- return Vector2( static_cast< float >( mAtlasList[ atlas - 1u ].mWidth ),
- static_cast< float >( mAtlasList[ atlas - 1u ].mHeight ) );
- }
- else
- {
- return Vector2::ZERO;
+ return mAtlasList[ atlas ].mSize;
}
+ return EMPTY_SIZE;
}
AtlasManager::SizeType AtlasManager::GetFreeBlocks( AtlasId atlas ) const
if ( atlas && atlas <= mAtlasList.size() )
{
uint32_t index = atlas - 1u;
- uint32_t width = mAtlasList[ index ].mWidth;
- uint32_t height = mAtlasList[ index ].mHeight;
- uint32_t blockWidth = mAtlasList[ index ].mBlockWidth;
- uint32_t blockHeight = mAtlasList[ index ].mBlockHeight;
+ uint32_t width = mAtlasList[ index ].mSize.mWidth;
+ uint32_t height = mAtlasList[ index ].mSize.mHeight;
+ uint32_t blockWidth = mAtlasList[ index ].mSize.mBlockWidth;
+ uint32_t blockHeight = mAtlasList[ index ].mSize.mBlockHeight;
SizeType widthInBlocks = width / blockWidth;
SizeType heightInBlocks = height / blockHeight;
uint32_t blockCount = widthInBlocks * heightInBlocks;
// Check free previously unallocated blocks and any free blocks
- blockCount -= mAtlasList[ index ].mNextFreeBlock - mAtlasList[ index ].mFreeBlocksList.Size();
+ if ( mAtlasList[ index ].mNextFreeBlock )
+ {
+ blockCount -= mAtlasList[ index ].mNextFreeBlock -1u - mAtlasList[ index ].mFreeBlocksList.Size();
+ }
+ else
+ {
+ blockCount = mAtlasList[ index ].mFreeBlocksList.Size();
+ }
return blockCount;
}
else
for ( uint32_t i = 0; i < atlasCount; ++i )
{
- SizeType width = mAtlasList[ i ].mWidth;
- SizeType height = mAtlasList[ i ].mHeight;
- SizeType blockWidth = mAtlasList[ i ].mBlockWidth;
- SizeType blockHeight = mAtlasList[ i ].mBlockHeight;
-
- entry.mWidth = width;
- entry.mHeight = height;
- entry.mBlockWidth = blockWidth;
- entry.mBlockHeight = blockHeight;
- entry.mTotalBlocks = ( width / blockWidth ) * ( height / blockHeight );
+ entry.mSize = mAtlasList[ i ].mSize;
+ entry.mTotalBlocks = ( entry.mSize.mWidth / entry.mSize.mBlockWidth ) * ( entry.mSize.mHeight / entry.mSize.mBlockHeight );
uint32_t reuseBlocks = mAtlasList[ i ].mFreeBlocksList.Size();
entry.mBlocksUsed = mAtlasList[ i ].mNextFreeBlock ? mAtlasList[ i ].mNextFreeBlock - reuseBlocks - 1u: entry.mTotalBlocks - reuseBlocks;
entry.mPixelFormat = GetPixelFormat( i + 1 );
metrics.mAtlasMetrics.PushBack( entry );
- uint32_t size = width * height;
+ uint32_t size = entry.mSize.mWidth * entry.mSize.mHeight;
if ( entry.mPixelFormat == Pixel::BGRA8888 )
{
size <<= 2;
metrics.mTextureMemoryUsed = textureMemoryUsed;
}
+Material AtlasManager::GetMaterial( AtlasId atlas ) const
+{
+ if ( atlas && atlas <= mAtlasList.size() )
+ {
+ return mAtlasList[ atlas -1u ].mMaterial;
+ }
+ Material null;
+ return null;
+}
+
+Sampler AtlasManager::GetSampler( AtlasId atlas ) const
+{
+ if ( atlas && atlas <= mAtlasList.size() )
+ {
+ return mAtlasList[ atlas -1u ].mSampler;
+ }
+ Sampler null;
+ return null;
+}
} // namespace Internal