[C++ SFML 3.0] Punkty na obwodzie kształtu składającego się z kwadratów

void Building::generateRoofMask()
{
    std::shared_ptr < BuildingPrefab > bp = std::dynamic_pointer_cast < BuildingPrefab >( _prefab.lock() );
   
    if( !bp ) return;
   
    int w = bp->_wallsSize.x;
    int h = bp->_wallsSize.y;
   
    std::vector < bool > solid( w * h, false );
   
    for( int y = 0; y < h; y++ ) {
        for( int x = 0; x < w; x++ ) {
           
            if( bp->_walls[ y * w + x ] > - 1 )
                 solid[ y * w + x ] = true;
           
        }
    }
   
    int fw = w + 2;
    int fh = h + 2;
   
    std::vector < bool > outside( fw * fh, false );
    std::queue < sf::Vector2i > q;
   
    q.push( sf::Vector2i( 0, 0 ) );
    outside[ 0 ] = true;
   
    const int dx[ 4 ] = { 1, - 1, 0, 0 };
    const int dy[ 4 ] = { 0, 0, 1, - 1 };
   
    while( !q.empty() )
    {
        sf::Vector2i p = q.front();
        q.pop();
       
        for( int dir = 0; dir < 4; dir++ )
        {
            int nx = p.x + dx[ dir ];
            int ny = p.y + dy[ dir ];
           
            if( nx < 0 || ny < 0 || nx >= fw || ny >= fh )
                 continue;
           
            if( outside[ ny * fw + nx ] )
                 continue;
           
            int ox = nx - 1;
            int oy = ny - 1;
           
            bool blocked = false;
           
            if( ox >= 0 && oy >= 0 && ox < w && oy < h )
                 blocked = solid[ oy * w + ox ];
           
            if( blocked )
                 continue;
           
            outside[ ny * fw + nx ] = true;
            q.push( sf::Vector2i( nx, ny ) );
        }
    }
   
    _roof.assign( w * h, false );
   
    for( int y = 0; y < h; y++ ) {
        for( int x = 0; x < w; x++ ) {
           
            bool isOutside = outside[( y + 1 ) * fw +( x + 1 ) ];
           
            if( !isOutside )
                 _roof[ y * w + x ] = true; // pole wewnątrz budynku
           
        }
    }
}

void Building::generateRoofVertexArray( float scale )
{
    _roofVertexArray.clear();
    _roofVertexArray.setPrimitiveType( sf::PrimitiveType::Triangles );
   
    std::shared_ptr < BuildingPrefab > bp = std::dynamic_pointer_cast < BuildingPrefab >( _prefab.lock() );
   
    if( !bp ) return;
   
    int w = bp->_wallsSize.x;
    int h = bp->_wallsSize.y;
   
    int offset = 64;
    for( int y = 0; y < h; y++ ) {
        for( int x = 0; x < w; x++ ) {
            if( !_roof[ y * w + x ] )
                 continue;
           
            float px = float( _position.x ) + float( x ) * 32.f * scale;
            float py = float( _position.y ) + float( y ) * 32.f * scale;
           
            sf::Color c( 128, 0, 0 );
           
            _roofVertexArray.append( sf::Vertex( sf::Vector2f( px, py - offset ), c ) );
            _roofVertexArray.append( sf::Vertex( sf::Vector2f( px +( 32.f * scale ), py - offset ), c ) );
            _roofVertexArray.append( sf::Vertex( sf::Vector2f( px +( 32.f * scale ), py - offset +( 32.f * scale ) ), c ) );
           
            _roofVertexArray.append( sf::Vertex( sf::Vector2f( px, py - offset ), c ) );
            _roofVertexArray.append( sf::Vertex( sf::Vector2f( px +( 32.f * scale ), py - offset +( 32.f * scale ) ), c ) );
            _roofVertexArray.append( sf::Vertex( sf::Vector2f( px, py - offset +( 32.f * scale ) ), c ) );
        }
    }
}

std::vector < std::vector < bool >> mask;

std::shared_ptr < BuildingPrefab > bp = std::dynamic_pointer_cast < BuildingPrefab >( _prefab.lock() );

if( !bp ) return;

// create mash using floor size
for( auto & row: bp->_floor )
     mask.push_back( std::vector < bool >( row.size(), false ) );

// fill mask with floor
for( int y = 0; y < bp->_floor.size(); y += 1 ) {
    for( int x = 0; x < bp->_floor[ 0 ].size(); x += 1 ) {
        if( bp->_floor[ y ][ x ] > 0 )
             mask[ y ][ x ] = true;
       
    }
}

// fill mask with walls
for( int y = 0; y < bp->_walls.size(); y += 1 ) {
    for( int x = 0; x < bp->_walls[ 0 ].size(); x += 1 ) {
        if( bp->_walls[ y ][ x ] > - 1 ) {
            mask[ y * 2 ][ x * 2 ] = true;
            mask[ y * 2 ][ x * 2 + 1 ] = true;
            mask[ y * 2 + 1 ][ x * 2 ] = true;
            mask[ y * 2 + 1 ][ x * 2 + 1 ] = true;
        }
    }
}


// draw mask
for( int y = 0; y < mask.size(); y += 1 ) {
    for( int x = 0; x < mask[ 0 ].size(); x += 1 ) {
        std::wcout <<( mask[ y ][ x ] ? L"1": L"0" );
    }
    std::wcout << std::endl;
}


// divide mask into rectangles
std::vector < sf::IntRect > rects;

for( int y = 0; y < mask.size(); y += 1 ) {
    for( int x = 0; x < mask[ y ].size(); x += 1 ) {
        if( !mask[ y ][ x ] )
             continue;
       
        int width = 0;
        while( x + width < mask[ y ].size() && mask[ y ][ x + width ] ) {
            width += 1;
        }
       
        int height = 0;
        while( y + height < mask.size() ) {
           
            bool fullRow = true;
           
            for( int xx = x; xx < x + width; xx++ ) {
                if( !mask[ y + height ][ xx ] ) {
                    fullRow = false;
                    break;
                }
            }
           
            if( !fullRow )
                 break;
           
            height += 1;
        }
       
        rects.push_back( sf::IntRect( sf::Vector2i( x, y ), sf::Vector2i( width, height ) ) );
       
        // unselect the rectangle in the mask
        for( int yy = y; yy < y + height; yy++ ) {
            for( int xx = x; xx < x + width; xx++ ) {
                mask[ yy ][ xx ] = false;
            }
        }
    }
}

// draw debug rectangles
for( auto & rect: rects ) {
    std::wcout << L"Rect: " << rect.position.x << L"," << rect.position.y << L" - " << rect.size.x << L"x" << rect.size.y << std::endl;
}
[ cpp ]