sf::IntRect pochylonego chunka mapy 3D w płaszczyźnie SFMLA 2D

sf::IntRect Chunk::getRect() {
   
    sf::IntRect rect;
    rect.position.x = _coords.x * tilesCols * Tile::tileSize;
    rect.position.y = _coords.y * tilesRows * Tile::tileSize;
    rect.size.x = tilesCols * Tile::tileSize;
    rect.size.y = tilesRows * Tile::tileSize;
   
    // TO-DO - to delete
    if( MapEditor::editor->_camera ) {
        sf::View view = Main::render_window->getView();
        sf::Vector2f cameraCenter = view.getCenter();
        sf::Vector2u windowSize = Main::render_window->getSize();
       
        float zoom = MapEditor::editor->_camera->_zoom;
       
        if( windowSize.x == 0 || windowSize.y == 0 || zoom <= 0.f )
             return sf::IntRect();
       
        sf::Vector2f size( float( windowSize.x ) / zoom, float( windowSize.y ) / zoom );
        float aspect = float( windowSize.x ) / windowSize.y;
        float fov = 60.f;
        float distance =( size.y * 0.5f ) / std::tan( fov * 0.5f * 3.14159265f / 180.f );
        float angle = sf::degrees( MapEditor::editor->_camera->_angle ).asRadians();
       
        float s = std::sin( angle );
        float c = std::cos( angle );
        float f = 1.7320508f;
       
        float width = float( tilesCols * Tile::tileSize );
        float height = float( tilesRows * Tile::tileSize );
       
        float x = float( _coords.x ) * width;
        float y = float( _coords.y ) * height;
       
        const sf::Vector2f points[ ] = {
            { x, y },
            { x + width, y },
            { x + width, y + height },
            { x, y + height }
        };
       
        float minX = std::numeric_limits < float >::max();
        float minY = std::numeric_limits < float >::max();
        float maxX = std::numeric_limits < float >::lowest();
        float maxY = std::numeric_limits < float >::lowest();
       
        for( const auto & point: points ) {
            float px = point.x - cameraCenter.x;
            float py = point.y - cameraCenter.y;
           
            float rotatedX = px;
            float rotatedY = py * c;
            float rotatedZ = py * s;
           
            float depth = distance - rotatedZ;
           
            // Przy przecięciu płaszczyzny bliskiej nie odrzucamy chunka.
            if( depth <= 0.1f ) {
                minX = cameraCenter.x - size.x * 0.5f;
                minY = cameraCenter.y - size.y * 0.5f;
                maxX = cameraCenter.x + size.x * 0.5f;
                maxY = cameraCenter.y + size.y * 0.5f;
                break;
            }
           
            // Projekcja jak w shaderze + dzielenie przez W.
            float ndcX =( rotatedX * f / aspect ) / depth;
            float ndcY =( - rotatedY * f ) / depth;
           
            // Przeliczenie do jednostek widoku, nie pikseli okna.
            float projectedX = cameraCenter.x + ndcX * size.x * 0.5f;
            float projectedY = cameraCenter.y - ndcY * size.y * 0.5f;
           
            minX = std::min( minX, projectedX );
            minY = std::min( minY, projectedY );
            maxX = std::max( maxX, projectedX );
            maxY = std::max( maxY, projectedY );
        }
       
        int left = int( std::floor( minX ) );
        int top = int( std::floor( minY ) );
        int right = int( std::ceil( maxX ) );
        int bottom = int( std::ceil( maxY ) );
       
        return sf::IntRect( sf::Vector2i( left, top ), sf::Vector2i( right - left, bottom - top ) );
    }
   
    return rect;
   
}