[Løst] Viewport frustum med glm

[GeirGrusom]

Jeg holder på med et spill for tiden, og har egentlig kommet ganske langt på det jeg trodde ville være mest komplisert. Jeg har derimot benyttet et mattebibliotek denne gangen (GLM) og sliter med at uthenting av clip-plan fra kamera frustum ikke funker helt som forventet.

 

Jeg har følgende kode:

Frustum::Frustum(const glm::mat4& viewProj)
{
 planes[0] = Plane(viewProj[3] + viewProj[0]); // left
 planes[1] = Plane(viewProj[3] - viewProj[0]); // Right
 planes[2] = Plane(viewProj[3] - viewProj[1]); // Top
 planes[3] = Plane(viewProj[3] + viewProj[1]); // Bottom
 planes[4] = Plane(viewProj[3] + viewProj[2]); // Front
 planes[5] = Plane(viewProj[3] - viewProj[2]); // Back
 for(auto& plane : planes)
plane.Normalize();
}
bool Frustum::Intersects(const vec3& point)
{
 for(auto& plane : planes)
 {
auto val = dot(plane.Normal(), point);
// If point lies on the positive side of any of the planes, it does not intersect
if(val <= plane.D())
  return false;
 }
 return true;
}

Unit-test:

void FrustumPointIntersectionTest()
{
 // Arrange
 auto projection = perspective(90.0f /* Fovy */, 800.0f / 600.0f /* aspect */, 0.1f /* near */, 10.0f /* far */);
 auto view = lookAt(vec3(0, 0, 0) /* eye */, vec3(0, 0, 1) /* lookat */, vec3(0, 1, 0) /* up */);
 Frustum frustum(view * projection);
 // Assert that a point way behind the near plane of the viewport does not intersect the viewport frustum
 assert(frustum.Intersects(vec3(0, 0, -10.0f)) == false);
 // Assert that a point on the back side of the near plane is visible
 assert(frustum.Intersects(vec3(0, 0, 2.0f)) == true);
}

 

Den andre asserten feiler.

Litt vanskelig å si på de andre, men front plane og back plane ser ut til å peke i riktig retning, men distansen er helt på jordet, men jeg vet ikke hva jeg isåfall gjør feil der.

edit: jævla møkka-3g

 

edit2:

 

Litt mer info: dette benytter seg av glm mattebiblioteket. Her er kode for Plane og Frustum:

 

 

Frustum.h

#pragma once
#include "main.h"
#include "Plane.h"


class Frustum
{
private:
 Plane planes[6];
public:
 Frustum(const glm::mat4x4& viewproj);
 bool Intersects(const glm::vec3& point);
 bool Intersects(const BoundingBox& box);
};

Frustum.cpp

#include "main.h"
#include "Frustum.h"
using namespace glm;

Frustum::Frustum(const glm::mat4& viewProj)
{
 planes[0] = Plane(viewProj[3] + viewProj[0]); // left
 planes[1] = Plane(viewProj[3] - viewProj[0]); // Right
 planes[2] = Plane(viewProj[3] - viewProj[1]); // Top
 planes[3] = Plane(viewProj[3] + viewProj[1]); // Bottom
 planes[4] = Plane(viewProj[3] + viewProj[2]); // Front
 planes[5] = Plane(viewProj[3] - viewProj[2]); // Back
 for(auto& plane : planes)
plane.Normalize();
}
bool Frustum::Intersects(const vec3& point)
{
 for(auto& plane : planes)
 {
auto val = dot(plane.Normal(), point);
// If point lies on the positive side of any of the planes, it does not intersect
if(val <= plane.D())
  return false;
 }
 return true;
}

Plane.h

#pragma once
#include "main.h"
class Plane sealed
{
private:
 glm::vec3 normal;
 float d;
public:
 glm::vec3& Normal();
 float& D();
 Plane();
 Plane(const glm::vec4& plane);
 Plane(const glm::vec3& normal, const float d);
 void Normalize();
 float& X();
 float& Y();
 float& Z();
 float& W();
};

 

Plane.cpp

#include "main.h"
#include "Plane.h"
using namespace glm;
float& Plane::X()
{
 return normal.x;
}
float& Plane::Y()
{
 return normal.y;
}
float& Plane::Z()
{
 return normal.z;
}
float& Plane::W()
{
 return d;
}
float& Plane:()
{
 return d;
}
vec3& Plane::Normal()
{
 return normal;
}
Plane::Plane()
 : normal(vec3(0, 0, 0)), d(0.0f)
{
}
Plane::Plane(const vec4& plane)
 : normal(vec3(plane.x, plane.y, plane.z)), d(plane.w)
{
}
Plane::Plane(const vec3& normal, const float d)
 : normal(normal), d(d)
{
}
void Plane::Normalize()
{
 const auto len = length(normal);
 normal /= len, d /= len;
}

 

 

Endret 29. august 2012 av GeirGrusom

[GeirGrusom]

Løsningen var å transponere matrisen, og snu sammenligningen i intersect-testen.