Obstacle avoidance behaviour is in (that should be all behaviors)

Source/ComponentSteering.cpp

@@ -48,6 +48,11 @@ void ComponentSteering::OnSave(Config& config) const
 	config.AddUInt("Path", (path) ? path->GetGameObject()->GetUID() : 0);
 	config.AddFloat("Path Offset", path_offset);
 	config.AddFloat("Path Prediction", path_prediction);
+
+	config.AddFloat("Separation Radius", separation_radius);
+
+	config.AddFloat("Obstacle Distance", obstacle_avoid_distance);
+	config.AddFloat("Obstacle Detector", obstacle_detector_len);
 }
 
 // ---------------------------------------------------------
@@ -72,6 +77,9 @@ void ComponentSteering::OnLoad(Config * config)
 
 	path_offset = config->GetFloat("Path Offset", 0.1f);
 	path_prediction = config->GetFloat("Path Prediction", 0.0f);
+	separation_radius = config->GetFloat("Separation Radius", 10.0f);
+	obstacle_avoid_distance = config->GetFloat("Obstacle Distance", 3.0f);
+	obstacle_detector_len = config->GetFloat("Obstacle Detector", 3.0f);
 }
 
 // ---------------------------------------------------------
@@ -157,9 +165,11 @@ void ComponentSteering::OnUpdate(float dt)
 		mov_velocity += Separation();
 		break;
 	case ComponentSteering::collision_avoidance:
-		//mov_velocity += Arrive(Pursue(goal->GetGlobalPosition(), goal->GetVelocity()));
 		mov_velocity += CollisionAvoidance();
 		break;
+	case ComponentSteering::obstacle_avoidance:
+		mov_velocity += ObstacleAvoidance();
+		break;
 	case ComponentSteering::unknown:
 		break;
 	default:
@@ -253,8 +263,6 @@ void ComponentSteering::OnDebugDraw(bool selected) const
 			} break;
 			case separation:
 			{
-				DebugDraw(Circle(game_object->GetGlobalPosition(), float3::unitY, separation_radius));
-
 				vector<GameObject*> results;
 				App->level->FindNear(game_object->GetGlobalPosition(), separation_radius, results);
 
@@ -270,11 +278,30 @@ void ComponentSteering::OnDebugDraw(bool selected) const
 						DebugDrawArrow(direction.Normalized() * force, offset, Green, game_object->GetGlobalTransformation());
 					}
 				}
-			} break;
+			} // fallback
 			case collision_avoidance:
 			{
 				DebugDraw(Circle(game_object->GetGlobalPosition(), float3::unitY, separation_radius));
-
+			} break;
+			case obstacle_avoidance:
+			{
+				float3 a = game_object->GetGlobalTransformation().TransformPos(float3::unitZ * game_object->GetRadius());
+				float3 b = game_object->GetGlobalTransformation().TransformPos(float3::unitZ * (game_object->GetRadius() + obstacle_detector_len));
+
+				LineSegment detector(a, b);
+				DebugDraw(detector, Yellow);
+
+				float dist;
+				float3 normal;
+				const GameObject* go = App->level->CastRayOnBoundingBoxes(detector, dist, normal);
+
+				if (go != nullptr)
+				{
+					float3 hit_pos = detector.GetPoint(dist);
+					float3 ret = hit_pos + normal * obstacle_avoid_distance;
+					DebugDraw(LineSegment(hit_pos, ret), Yellow);
+					DebugDraw(Circle(ret, float3::unitY, 2.0f), Red);
+				}
 			} break;
 		}
 	}
@@ -495,7 +522,7 @@ float3 ComponentSteering::CollisionAvoidance() const
 	vector<GameObject*> results;
 	App->level->FindNear(game_object->GetGlobalPosition(), separation_radius, results);
 
-	float smallest_collision_time = -inf;
+	float smallest_collision_time = inf;
 	const GameObject* go_to_avoid = nullptr;
 	float3 smallest_relative_vel;
 	float3 smallest_relative_pos;
@@ -556,15 +583,38 @@ float3 ComponentSteering::CollisionAvoidance() const
 	return ret;
 }
 
+// ---------------------------------------------------------
+float3 ComponentSteering::ObstacleAvoidance() const
+{
+	float3 ret = float3::zero;
+
+	float3 a = game_object->GetGlobalTransformation().TransformPos(float3::unitZ * game_object->GetRadius());
+	float3 b = game_object->GetGlobalTransformation().TransformPos(float3::unitZ * (game_object->GetRadius() + obstacle_detector_len));
+
+	LineSegment detector(a, b);
+
+	float dist;
+	float3 normal;
+	const GameObject* go = App->level->CastRayOnBoundingBoxes(detector, dist, normal);
+
+	if (go != nullptr)
+	{
+		float3 hit_pos = detector.GetPoint(dist);
+		ret = hit_pos + normal * obstacle_avoid_distance;
+	}
+
+	return ret;
+}
+
 // ---------------------------------------------------------
 void ComponentSteering::DrawEditor()
 {
-	static_assert(Behaviour::unknown == 14, "code needs update");
+	static_assert(Behaviour::unknown == 15, "code needs update");
 
 	static const char* behaviours[] = { 
 		"Seek", "Flee", "Arrive", "Align", "UnAlign", "Match Velocity", 
 		"Pursue", "Evade", "Face", "Look Ahead", "Wander", "Follow Path",
-		"Separation", "Collision Avoidance", "Unknown" };
+		"Separation", "Collision Avoidance", "Obstacle Avoidance", "Unknown" };
 
 	int behaviour_type = behaviour;
 	if (ImGui::Combo("Behaviour", &behaviour_type, behaviours, (int) Behaviour::unknown))
@@ -673,6 +723,12 @@ void ComponentSteering::DrawEditor()
 		{
 			ImGui::DragFloat("Radius", &separation_radius, 0.1f, 0.1f);
 		} break; 
+
+		case obstacle_avoidance:
+		{
+			ImGui::DragFloat("Detector Len", &obstacle_detector_len, 0.01f, 1.0f, 50.0f);
+			ImGui::DragFloat("Distance", &obstacle_avoid_distance, 0.01f, 1.0f, 10.0f);
+		}
 	}
 
 	// Curve editor! ---

Source/ComponentSteering.h

@@ -29,6 +29,7 @@ class ComponentSteering : public Component
 		follow_path,
 		separation,
 		collision_avoidance,
+		obstacle_avoidance,
 		unknown
 	};
 
@@ -64,6 +65,7 @@ class ComponentSteering : public Component
 	float3 FollowPath() const;
 	float3 Separation() const;
 	float3 CollisionAvoidance() const;
+	float3 ObstacleAvoidance() const;
 
 private:
 	uint goal_uid = 0;
@@ -102,6 +104,9 @@ class ComponentSteering : public Component
 
 	float separation_radius = 10.0f;
 
+	float obstacle_detector_len = 5.0f;
+	float obstacle_avoid_distance = 5.0f;
+
 private:
 
 	Behaviour behaviour = Behaviour::seek;

Source/GameObject.cpp

@@ -737,3 +737,11 @@ float3 GameObject::GetVelocity() const
 {
 	return velocity;
 }
+
+// ---------------------------------------------------------
+float GameObject::GetRadius() const
+{
+	if(global_bbox.IsFinite())
+		return global_bbox.HalfDiagonal().Length();
+	return 0.0f;
+}

Source/GameObject.h

@@ -83,6 +83,7 @@ class GameObject
 	bool HasComponent(Component::Types type) const;
 
 	float3 GetVelocity() const;
+	float GetRadius() const;
 
 private:
 	AABB local_bbox;

Source/ModuleLevelManager.cpp

@@ -362,6 +362,36 @@ GameObject* ModuleLevelManager::CastRay(const LineSegment& segment, float& dist)
 	return candidate;
 }
 
+void ModuleLevelManager::RecursiveTestRayBBox(const LineSegment & segment, float & dist, float3 & normal, GameObject ** best_candidate) const
+{
+	map<float, GameObject*> objects;
+	quadtree.CollectIntersections(objects, segment);
+
+	for (map<float, GameObject*>::const_iterator it = objects.begin(); it != objects.end(); ++it)
+	{
+		// Look for meshes
+		GameObject* go = it->second;
+		if (go->HasComponent(Component::Types::Geometry) == true)
+		{
+			float closer = inf;
+			*best_candidate = (GameObject*) go;
+			dist = it->first;
+
+			// let's find out the plane that hit the segment and fill in the normal
+			for (int i = 0; i < 6; ++i)
+			{
+				Plane p(go->global_bbox.FacePlane(i));
+				float d;
+				if (p.Intersects(segment, &d))
+				{
+					if (d < closer)
+						normal = p.normal;
+				}
+			}
+		}
+	}
+}
+
 void ModuleLevelManager::RecursiveTestRay(const LineSegment& segment, float& dist, GameObject** best_candidate) const
 {
 	map<float, GameObject*> objects;
@@ -413,6 +443,15 @@ GameObject* ModuleLevelManager::CastRay(const Ray & ray, float& dist) const
 	return candidate;
 }
 
+GameObject * ModuleLevelManager::CastRayOnBoundingBoxes(const LineSegment & segment, float & dist, float3 & normal) const
+{
+	dist = inf;
+	normal = float3::zero;
+	GameObject* candidate = nullptr;
+	RecursiveTestRayBBox(segment, dist, normal, &candidate);
+	return candidate;
+}
+
 void ModuleLevelManager::RecursiveTestRay(const Ray& ray, float& dist, GameObject** best_candidate) const
 {
 	map<float, GameObject*> objects;

Source/ModuleLevelManager.h

@@ -49,9 +49,11 @@ class ModuleLevelManager : public Module
 	GameObject* Validate(const GameObject* pointer) const;
 	GameObject* CastRay(const LineSegment& segment, float& dist) const;
 	GameObject* CastRay(const Ray& ray, float& dist) const;
+	GameObject* CastRayOnBoundingBoxes(const LineSegment& segment, float& dist, float3& normal) const;
 	void FindNear(const float3& position, float radius, std::vector<GameObject*>& results) const;
 
 private:
+	void RecursiveTestRayBBox(const LineSegment& segment, float& dist, float3& normal, GameObject** best_candidate) const;
 	void RecursiveTestRay(const LineSegment& segment, float& dist, GameObject** best_candidate) const;
 	void RecursiveTestRay(const Ray& ray, float& dist, GameObject** best_candidate) const;
 	void RecursiveDrawGameObjects(const GameObject* go) const;