Lu',

Je suis en train d'essayer d'implementer un View frustum culling. J'ai essayé de le faire moi meme, cad sans copier-collé le code d'un tuto.

Je me suis tout de même un peu renseigné sur quelle methode partir, et j'ai vu que celle des plans et normales (au plan) est la plus utilisée. Je me suis donc lancé mais cela marche moyen moyen. 

Exemple 1: j'ai 1 seul objet visible (non, il ny' a pas 1 caché derriere ou supperposé) et pourtant, sur la console où j'affiche le nombre d'objets dessinés, il y'en a 2.

Exemple 2 : c'est exactement la même scène, sauf que cette fois la camera est plus près de l'objet. J'ai bien 1 objet visible pour 1 objet dessiné.

Je ne sais pas si l'erreur vient de la determinations des plans du view frustum, ou des tests que j'effectue pour verifier la "visibilité" d'un objet. Je vous mets donc les 2 codes:

Determinations du view Frustum (calcul d'un point et de la normal de chaque plan)

const ViewFrustum Camera::getViewFrustum()
{	
	auto nearSide = std::tan(glm::radians(fov_ / 2.0f)) * 0.1f;
	auto nearCenter = position_ + front_ * 0.1f ;

	ViewFrustum viewFrustum{};
	viewFrustum.nearPlane = std::make_pair(nearCenter, front_);
	viewFrustum.farPlane = std::make_pair(position_ + front_ * viewRange_, -front_);


	auto toTheLeftRotationMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(fov_ / 2.0f), up_);
	viewFrustum.leftPlane = std::make_pair(nearCenter - right_ * nearSide , glm::vec3(toTheLeftRotationMatrix * glm::vec4(right_, 0.0f)));
	
	auto toTheRightRotationMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(fov_ / 2.0f), -up_);
	viewFrustum.rightPlane = std::make_pair(nearCenter + right_ * nearSide, glm::vec3(toTheRightRotationMatrix * glm::vec4(-right_, 0.0f)));

	auto toTheTopRotationMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(fov_ / 2.0f), right_);
	viewFrustum.topPlane = std::make_pair(nearCenter + up_ * nearSide, glm::vec3(toTheTopRotationMatrix * glm::vec4(-up_, 0.0f)));
	
	auto toTheBottomRotationMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(fov_ / 2.0f), -right_);
	viewFrustum.bottomPlane = std::make_pair(nearCenter - up_ * nearSide, glm::vec3(toTheBottomRotationMatrix * glm::vec4(up_, 0.0f)));
	
	return viewFrustum;
}

Test de visibilité (calcul de la distance par rapport à un point du plan, puis on compare s'il est a gauche/droite/haut/bas par rapport au même plan):

bool ViewFrustum::isInside(const glm::vec3 & pos) const
{

	if (glm::dot(pos - nearPlane.first, nearPlane.second) < 0.0f && glm::dot(pos - farPlane.first, farPlane.second) > 0.0f)
	{
		return false;
	}
	else
	{
		if (glm::dot(pos - leftPlane.first, leftPlane.second) > 0.0f && glm::dot(pos - rightPlane.first, rightPlane.second) < 0.0f)
		{
			return false;
		}
		else
		{
			if (glm::dot(pos - topPlane.first, topPlane.second) > 0.0f && glm::dot(pos - bottomPlane.first, bottomPlane.second) < 0.0f)
			{
				return false;
			}
			else
			{
				return true;
			}			
		}
	}
}

où la strucutre viewFrustum est de la forme:

struct ViewFrustum
{
	//pair of [point, normal]
	std::pair<glm::vec3, glm::vec3> nearPlane;
	std::pair<glm::vec3, glm::vec3> farPlane;
	std::pair<glm::vec3, glm::vec3> leftPlane;
	std::pair<glm::vec3, glm::vec3> rightPlane;
	std::pair<glm::vec3, glm::vec3> topPlane;
	std::pair<glm::vec3, glm::vec3> bottomPlane;

	bool isInside(const glm::vec3 & pos) const;
};

Vu qu'il s'agit plus de problème de maths/algorithmie, je préfère poster ici, bien que ce soit écrit en C++. J'ai essayé de rendre le code le plus lisible possible, donc normalement meme ceux qui ne code pas en C++ peuvent comprendre.

Merci d'avance!

-
Edité par eugchriss 21 septembre 2018 à 9:37:43