AABB/OBB/Ray/Frustum/Circle/Sphere

[marvinschrd]

Introduction

Our task is to work on AABB, OBB, Ray, Frustum and Circle/Sphere implementation for the GPR5204 module.

AABB

GetCenter

Method to get the center of the AABB

GetExtent

Method to get the extent of the AABB

Overlap

Method to detect if two AABB are overlapping

Contains

Method to detect if a AABB is contained inside another

OBB (still searching and getting more informations)

GetCenter

Method that return the center position of this OBB

GetSize

Method that return the size of the OBB

... (more or less when we are sure)

Ray

Origin

Method that return the origin of the ray (vector3)

Direction

Method that return the direction of the ray (vector3)

SetOrigin

Method to set the origin of the ray

SetDirection

Method to set the direction of the ray

GetPointInRay

Method that get the position of a point “t” along the ray vector3 {origin + ( t * direction)}

Frustum (still searching and getting informations)

CalculateFrustum

Method that will calculate the frustum and its planes (Still searching informations)

IsPointInFrustum

Method that takes a vec3 and return if the point is inside the frustum or not

IsSphereInFrsutum

Method that takes a vec3 and a radius and return if the sphere is inside the frustum or not

...(more when we are sure)

Circle/Sphere

SetRadius

Method that will set the radius of the circle or sphere

GetRadius

Method that will return the radius of the circle or sphere

SetPosition

Method that will set the position of the circle or sphere

GetArea ( for circle)

Method that will return the area of the circle {MPI * (radius * radius_)}

GetArea (for sphere)

Method that will return the area of the sphere { 4 M_PI (radius_ * radius)}

Questions

We still have a lot of information to find and, most importantly, we don’t know for each of these implementations to what extent we need to implement them. We don’t really know what the minimal function expected for them are and we are a bit lost in knowing what amount of work we have to do.

Question are the following :

• What are the minimum expected function for each implementations ?
• Should we create a different file for each of them ?

[EliasFarhan]

Thanks for the features' list, here are some little details and answer to your questions:

• What are the attributes for each structures and how are you going to store them? For example for the AABB2 (or Aabb2?) vec2f center and extends, or vec2f min and max?
• In priority, OBB is last, so focus on AABB, Ray, Circle/Sphere and Frustum first.
• Please put each structures in its own file and add a separate contact2.h and contact3.h for overlapping functions, it makes more sense to have:

  overlap(aabb1, aabb2);

  instead of

  aabb1.Overlap(aabb2);

  Because then you have an overloaded overlap function.

• Overlap is great, but I would like to check where my two Ray2 are overlapping. A solve function? I should be able to know where a Ray hit a circle/sphere, aabb at least.
• When the result of a method is not trivial, prefer using Calculate instead of Get (Get has a strong connotation of getting an attribute, but if you calculate it, now we know it is a bit more costly)
• Instead of implementing getter method for the attributes, you can simply use a struct (it's C++ so it's okay to be able to access attributes of mathematical object).
• Prefer using method overload Contains for the Frustum, with something like:

  class Frustum
  {
  ...
  bool Contains(const Sphere& sphere);
  bool Contains(const Aabb3& aabb);
  bool Contains(const Point& point);

• Are you going to define the struct Point?