ogltest/src/collision.cpp

#include "jsonloader.h"
#include "collision.h"


namespace collision {

//	static CollisionInfo Collider::test(PlaneCollider a, SphereCollider b, glm::vec3 pa, glm::vec3 pb);

//	static CollisionInfo Collider::test(SphereCollider a, PlaneCollider b, glm::vec3 pa, glm::vec3 pb);

//	static CollisionInfo Collider::test(AABBCollider a, PlaneCollider b, glm::vec3 pa, glm::vec3 pb);

//	static CollisionInfo Collider::test(PlaneCollider a, AABBCollider b, glm::vec3 pa, glm::vec3 pb);

//	static CollisionInfo Collider::test(AABBCollider a, AABBCollider b, glm::vec3 pa, glm::vec3 pb);


	CollisionInfo Collider::test(AABBCollider a, AABBCollider b, glm::vec3 pa, glm::vec3 pb) {
		CollisionInfo c;
		c.intersecting = false;
	}


	CollisionInfo Collider::test(SphereCollider a, SphereCollider b, glm::vec3 pa, glm::vec3 pb) {
		CollisionInfo c;
		c.intersecting = false;
		if (glm::distance(pa, pb) < a.radius + b.radius) {
			c.intersecting = true;
			glm::vec3 restore = pa - pb;
			restore *=  (a.radius + b.radius) / (glm::distance(pa, pb));
			c.restore = restore;
		}
		return c;
	}


	std::optional<AABBCollider> AABBCollider::from_json(json j) {
		// ["AABB": [0.1, 0.1]]
		try {
			if (!j.contains(AABBCollider::name)) {
				return {};
			}
			auto r = vec3_fromjson(j[AABBCollider::name]);
			if (!r) return {};
			return AABBCollider(*r);
		} catch (std::exception &e) {
			return {};
		}
	}

	std::optional<SphereCollider> SphereCollider::from_json(json j) {
		// ["SphereCollider": {"radius": 0.01}]
		try {
			if (!j.contains(SphereCollider::name)) {
				return {};
			}
			return SphereCollider((double)j[SphereCollider::name]["radius"]);
		} catch (std::exception &e) {
			return {};
		}
	}

	Collider::Collider (PlaneCollider p) : type(PLANE) {
		type = PLANE;
		inner.plane = p;
	}

	Collider::Collider (SphereCollider s) {
		type = SPHERE;
		inner.sphere = s;
	}

	Collider::Collider (AABBCollider a) {
		inner.aabb = a;
		type = AABB;
	}

	Collider::Collider (FPlaneCollider f) {
		type = FPLANE;;
		inner.fplane = f;
	}


	std::optional<Collider> Collider::from_json(json j) {
		if (j.count(PlaneCollider::name)) {
			return {};
			//return Collider(*PlaneCollider::from_json(j));
		} else if (j.count(FPlaneCollider::name)) {
			return {};
			//return Collider(*FPlaneCollider::from_json(j));
		} else if (j.count(names[AABB])) {
			return Collider(*AABBCollider::from_json(j));
		} else if (j.count(names[SPHERE])) {
			return Collider(*SphereCollider::from_json(j));
		} else  {
			return {};
		}
	}

	std::string Collider::get_name() {
		return names[type];
	}
};