SFML kolizja pikseli

Question

 Uczę się SFML'a i próbuję sobie zrobić gierkę która polega na tym że z góry spadają jakieś klocki itp. a gracz musi je wymijać prostokątem. Jak zrobić kolizję dla takich elementów:

a to mój kod dla klas gracza i tych "bloczków":

#ifndef TPLAYER_H
#define TPLAYER_H
#include <SFML/Graphics.hpp>


class TPlayer : public sf::Drawable
{
public:

	TPlayer(float t_X, float t_Y);
	TPlayer() = delete;
	virtual ~TPlayer() = default;
	void update();

	float moveRight();
	float moveLeft();




private:
	void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
	
	sf::Texture playerTexture;
	sf::Sprite playerSprite;
	sf::Texture *pTexture = &playerTexture;


	const double playerVelocity{4};
	sf::Vector2f velocity{ playerVelocity, 0.f };




};

#endif // TPLAYER_H

#include "TPlayer.h"
#include <SFML\Graphics.hpp>
#include "Collision.h"
#include <iostream>


TPlayer::TPlayer(float t_X, float t_Y)
{
	
	/*playerTexture.loadFromFile("player_texture.jpg");
	if (!playerTexture.loadFromFile("player_texture.jpg"))
	{
		std::cout << "Load failed!";
		
	}
	*/
	
	
	
	Collision::CreateTextureAndBitmask(playerTexture, "player_texture.jpg");
	playerSprite.setTexture(playerTexture);
	playerSprite.setPosition(t_X, t_Y);
	playerSprite.setOrigin(sf::Vector2f(playerSprite.getTexture()->getSize().x * 0.5, playerSprite.getTexture()->getSize().y * 0.5));

	

}

void TPlayer::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
	
	target.draw(this->playerSprite, states);
}

 void TPlayer::update()
{
	
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A) && this->moveLeft() >20)
	{
		
		playerSprite.move(-7, 0);
	}
	else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D) && this->moveRight() < 880 )
	{
		
		playerSprite.move(7, 0);
	}
	else
	{
		
		playerSprite.move(0, 0);
	}
}

float TPlayer::moveLeft()
{
	
	return this->playerSprite.getPosition().x - playerSprite.getOrigin().x / 2.f;
	
}

float TPlayer::moveRight()
{
	
	return this->playerSprite.getPosition().x + playerSprite.getOrigin().x / 2.f;
}

#pragma once
#include <SFML\Graphics.hpp>


class TBlocks:public sf::Drawable
{
public: 
	TBlocks(float t_X, float t_Y);
	TBlocks()=delete;
	virtual ~TBlocks() = default;

	void update_block();
	

private:
	void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
	sf::Texture block_texture;
	sf::Sprite blockSprite;
	sf::Texture *bTexture = &block_texture;
	std::string blocks[3];


};

#include "TBlocks.h"
#include "Collision.h"
#include <iostream>
#include <stdio.h>     
#include <SFML\Graphics.hpp>
#include <stdlib.h>  
#include <algorithm>
#include <random>
#include <time.h> 






TBlocks::TBlocks(float t_X, float t_Y)
{
	blocks[0] = "blocks/block_3.png";
	blocks[1] = "blocks/block_3.png";
	blocks[2] = "blocks/block_3.png";

	//RANDOMOWE BLOKI
	std::random_device rseed;
	std::mt19937 rgen(rseed()); 
	std::uniform_int_distribution<int> idist(0, 2); 

	int los = idist(rgen);
	
	
	
	Collision::CreateTextureAndBitmask(block_texture, blocks[los]);
	blockSprite.setTexture(block_texture);
	blockSprite.setPosition(t_X, t_Y);
	blockSprite.setOrigin(sf::Vector2f(blockSprite.getTexture()->getSize().x * 0.5, blockSprite.getTexture()->getSize().y * 0.8));
}

void TBlocks::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
	target.draw(this->blockSprite, states);
}
void TBlocks::update_block()
{
	blockSprite.move(0, 3);
}