当たり判定でサイズが変わると範囲がズレてしまう原因が知りたい。

Question

提示画像ですが当たり判定がズレてしまう原因がどうしてもわかりません。当たり判定の範囲がCELL,CELLの時は正常に当たり判定出来るのですが
CELL / 2のときになると当たり判定がズレてしまいます。これはどうすればいいのでしょうか？
プレイヤーとブロックと当たり判定のコードを確認しましたが大きさが変わっただけおかしくなる原因がわかりません。

画面左上が0,0になるように描画原点を修正しています。
CELLL 64
プレヤーCELL,CELL
ブロック CELL /2 , CELL / 2

#include "../../Header/Game/Scene.hpp"
#include <array>


Scene::Scene(Entry * e)
{
	Owner = e;

	std::shared_ptr<TextureData> player_sprite = LoadTexture("Assets/Player.png");
	std::shared_ptr<TextureData> block_sprite = LoadTexture("Assets/Block.png");





	//当たり判定
	Box_Collision_2D col;
	col.setEnable(true);
	col.setPosition(glm::ivec2(SCREEN_WIDTH / 2, -SCREEN_HEIGHT / 2));	//座標
	col.setSize(glm::ivec2(CELL / 2  , CELL / 2 ));	//当たり判定範囲





	block = std::make_unique<Block>(e, ObjectType::Block, block_sprite, 
		TextureUV{ glm::vec2(0,0),glm::vec2(CELL /2 ,CELL / 2 ) }, //UV
		glm::ivec2(SCREEN_WIDTH / 2, -SCREEN_HEIGHT / 2),//座標
		col);

	stage = std::make_unique<Stage>(e);
	player = std::make_unique<Player>(e,ObjectType::Player,player_sprite);
}

void Scene::Update()
{
//	stage->Update();
	player->Update();

	block->Update();
	if (Intersect_Rect_2D(player->mCol,block->mCol) == true)
	{
		player->Fix(block->mCol.getPosition(),ObjectType::Brick);
		printf("当たり ! \n");
	}



	
}

void Scene::Draw()
{	

//	stage->Draw();
	player->Draw();
	
	block->Draw();


}

Scene::~Scene()
{

}

//　矩形同士の交差判定
bool Intersect_Rect_2D(Box_Collision_2D& a,Box_Collision_2D& b)
{ 
    if (a.getEnable() == true && b.getEnable() == true)
    {
        /*
        printf("a.x %d\n", a.getSize().x);
        printf("a.y %d\n", a.getSize().y);
        printf("\n\n");
        printf("b.x %d\n", b.getSize().x);
        printf("b.y %d\n", b.getSize().y);
        */



        // 矩形の衝突判定
        if (((a.getPosition().x + a.getSize().x > b.getPosition().x) && (a.getPosition().x < b.getPosition().x + b.getSize().x))
            && ((a.getPosition().y + a.getSize().y > b.getPosition().y) && (a.getPosition().y < b.getPosition().y + b.getSize().y)))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

#include "../../Header/Game/Player.hpp"

//コンストラクタ
Player::Player(Entry* e, ObjectType type,std::shared_ptr<TextureData> data) : Actor_2D()
{
	Owner = e;	//Entry クラス

	mPosition = glm::ivec2(SCREEN_WIDTH /2 - 200 , -SCREEN_HEIGHT / 2 );	//初期座標
	mVector = glm::ivec2(0,1);		//向き
	//mUV = uv;						//UV座標
	mSpeed = SPEED;					//移動速度
	mSpeedpos = glm::ivec2(0,0);	//移動座標

	//当たり判定
	mCol.setEnable(true);					//有効
	mCol.setSize(glm::ivec2(CELL,CELL));	//当たり判定のサイズ
	
	mInputKey = std::make_unique<Input>(Owner);	//キー入力
	mSprite = std::make_unique<Sprite>(Owner,data);	//スプライト

}


// めり込みを修正
void Player::Fix(glm::ivec2 pos,ObjectType type)
{

	printf("レンガと衝突 ! \n");
	if (mVector == glm::ivec2(1, 0))
	{
		mPosition.x = pos.x - CELL;
	}
	else if (mVector == glm::ivec2(-1, 0))
	{
		mPosition.x = pos.x + CELL;
	}
	else if (mVector == glm::ivec2(0, 1))
	{
		mPosition.y = pos.y - CELL;
	}
	else if (mVector == glm::ivec2(0, -1))
	{
		mPosition.y = pos.y + CELL;
	}	
}

#include "../Header/Sprite.hpp"
#include "../Header/Shader.hpp"
#include "../Header/Entry.hpp"
#include "../Header/LoadTexture.hpp"
#include "../Header/VertexData.hpp"

// 数学ライブラリ
#include "glm/ext.hpp"
#include "glm/glm.hpp"


#include <vector>

// OpenCV 
#include <opencv2/core.hpp>

/*################################################################################################################
* 画像　描画クラス
################################################################################################################*/

//コンストラクタ
/*
* Entry クラス
* テクスチャ パス
* 描画する画像の寸法
*/
Sprite::Sprite(class Entry* g, std::shared_ptr<TextureData> sp ) : Transform_2D(g)
{
	//shader = new Shader(g, "Shader/2D/Sprite.vert", "Shader/2D/Sprite.frag");
	shader = std::make_shared<class Shader>(g,"Shader/2D/Sprite.vert", "Shader/2D/Sprite.frag");

	Owner = g;//Entryクラス
	
	Transform_2D::setTransfrom(glm::vec2(1,1),0,glm::vec2(0,0));	//トランスフォームを初期化

	//テクスチャを設定     
	glGenTextures(1, &TextureID);
	glBindTexture(GL_TEXTURE_2D, TextureID);

	//画像の大きさ
	mPicSize.x = (float)sp->mSize.x;
	mPicSize.y = (float)sp->mSize.y;

	
//	printf("%d\n",sp->mData->size());
	

	if (sp->mData->data() != NULL)
	{
		if (sp->channels == 3)
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)sp->mSize.x, (GLsizei)sp->mSize.y, 0, GL_RGB, GL_UNSIGNED_BYTE, sp->mData->data());
			printf("aa\n");

		}
		else if (sp->channels == 4)
		{
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)sp->mSize.x, (GLsizei)sp->mSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, sp->mData->data());
		}
	}
	else {
		std::cerr << "Unable to load texture: " <<std::endl;
	}


	//ミニマップを設定
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glGenerateMipmap(GL_TEXTURE_2D);

	//異方性フィルタリングを設定
	GLfloat largest;
	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, largest);




	//VAO
	glGenVertexArrays(1, &VAO);
	glBindVertexArray(VAO);

	//VBO
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, (sizeof(vertex) / sizeof(vertex[0])) * sizeof(VertexAttribute_2D), vertex, GL_STATIC_DRAW);



}

//描画
void Sprite::DrawGraph(glm::ivec2 pos, glm::vec2 start, glm::vec2 end)
{

	glm::vec2 mSize;

	mSize = end - start;	//描画範囲を取得

	if (mSize.x > mPicSize.x)
	{
		mSize.x = mPicSize.x;
	}

	if (mSize.y > mPicSize.y)
	{
		mSize.y = mPicSize.y;
	}

	//左上が原点になるように修正
	pos.x = (-SCREEN_WIDTH / 2) + (pos.x);
	pos.y = (SCREEN_HEIGHT / 2) + (pos.y);

	Transform_2D::UpdateTransform();		//トランスフォームを更新
	Transform_2D::setTransform_Move(pos);	//移動

	shader->Enable();	//シェーダーを有効にする
	shader->SetFloatUniform_3m("uViewMatrix", getViewMatrix());
	shader->SetFloatUniform_3m("uWorldMatrix", getWorldMatrix());


//	printf("mSize.x  %f\n", mSize.x);
//`	printf("start.x. x%f\n", end.x);

	/* // 描画座標の中心に画像を描画
	vertex[0] = VertexAttribute_2D{ -mSize.x / 2.0f,mSize.y / 2.0f,	    start.x / mPicSize.x   ,start.y / mPicSize.y };
	vertex[1] = VertexAttribute_2D{ -mSize.x / 2.0f,-mSize.y / 2.0f,	start.x / mPicSize.x   ,end.y / mPicSize.y };
	vertex[2] = VertexAttribute_2D{ mSize.x / 2.0f,-mSize.y / 2.0f,	    end.x / mPicSize.x     ,end.y / mPicSize.y };
	vertex[3] = VertexAttribute_2D{ -mSize.x / 2.0f,mSize.y / 2.0f,	    start.x / mPicSize.x  ,start.y / mPicSize.y };
	vertex[4] = VertexAttribute_2D{ mSize.x / 2.0f,-mSize.y / 2.0f,	    end.x / mPicSize.x    ,end.y / mPicSize.y };
	vertex[5] = VertexAttribute_2D{ mSize.x / 2.0f,mSize.y / 2.0f,		end.x / mPicSize.x    ,start.y / mPicSize.y };
	*/


	//左上が原点
	vertex[0] = VertexAttribute_2D{ 0,0,												start.x / mPicSize.x   ,start.y / mPicSize.y };
	vertex[1] = VertexAttribute_2D{ 0,-mSize.y,											start.x / mPicSize.x   ,end.y / mPicSize.y };
	vertex[2] = VertexAttribute_2D{ mSize.x,-mSize.y,									end.x / mPicSize.x     ,end.y / mPicSize.y };

	vertex[3] = VertexAttribute_2D{ 0 ,0,												start.x / mPicSize.x  ,start.y / mPicSize.y };
	vertex[4] = VertexAttribute_2D{ mSize.x,-mSize.y,									end.x / mPicSize.x    ,end.y / mPicSize.y };
	vertex[5] = VertexAttribute_2D{ mSize.x, 0,											end.x / mPicSize.x    ,start.y / mPicSize.y };
	



	//VAO
	glBindVertexArray(VAO);

	//VBO
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, (sizeof(vertex) / sizeof(vertex[0])) * sizeof(VertexAttribute_2D), vertex, GL_STATIC_DRAW);


	//頂点座標
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(VertexAttribute_2D), NULL);

	//UV座標
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(VertexAttribute_2D), (void*)(sizeof(float) * 2));

	glBindVertexArray(VAO);
	glBindTexture(GL_TEXTURE_2D, TextureID);
	glDrawArrays(GL_TRIANGLES, 0, (GLsizei)std::size(vertex));	

}



// 画像サイズを取得
glm::vec2 Sprite::getSize()
{
	return mPicSize;
}



// デストラクタ
Sprite::Sprite(const Sprite & sp) : Transform_2D(sp.Owner)
{
	//printf("あああああ\n");
	//shader = new Shader(sp.Owner, "Shader/2D/Sprite.vert", "Shader/2D/Sprite.frag");
	shader = std::make_shared<Shader>(sp.Owner, "Shader/2D/Sprite.vert", "Shader/2D/Sprite.frag");
	Owner = sp.Owner;//Entryクラス
	mPicSize.x = sp.mPicSize.x;
	mPicSize.y = sp.mPicSize.y;
//	printf("aaa\n");

}


// デストラクタ
Sprite::~Sprite()
{
//	printf("Sprite delete\n");

	// バッファを解放
	glDeleteBuffers(1, &VAO);
	glDeleteVertexArrays(1, &VAO);

	glBindVertexArray(0);
	glBindTexture(GL_TEXTURE_2D, 0);

	
	//delete shader;
	//shader = nullptr;
	glDeleteTextures(1,&TextureID);

}

Answer 1

blockオブジェクトにサイズを設定する部分が見当たりませんが、の周辺部分を見直してみてはいかがでしょうか？

下記のCELL/2はテクスチャのサイズ指定で、オブジェクトのサイズ指定ではないかと思われます。

block = std::make_unique<Block>(e, ObjectType::Block, block_sprite,
TextureUV{ glm::vec2(0,0),glm::vec2(CELL /2 ,CELL / 2 ) }, //UV
glm::ivec2(SCREEN_WIDTH / 2, -SCREEN_HEIGHT / 2),//座標
col);