Commit intelligent car spawner + closest track detector for debug lines

app/car_spawner.py

@@ -1,10 +1,78 @@
 import harfang as hg
-import json, os
+import json
+import os
 from utils import *
+from gui import DrawLine
+from random import uniform, randint
+
+
+def GetRandomVectorsOnTrack(node_track_data, car_pos):
+	track_data = node_track_data['track_data']
+	track_vectors = []
+	for track in track_data:
+		random_vec = hg.Vec3(99999, 99999, 99999)
+		track_straight = None
+		turn_index = 0
+		lerp_value = 0
+		if len(track['pos']) == 2:
+			track_straight = True
+			while hg.Dist(car_pos, random_vec) > 300 or hg.Dist(car_pos, random_vec) < 100:
+				lerp_value = uniform(0, 1)
+				random_vec = hg.Lerp(
+					track['pos'][0], track['pos'][1], lerp_value)
+				print(hg.Dist(car_pos, random_vec))
+
+		elif len(track['pos']) > 2:
+			track_straight = False
+			while hg.Dist(car_pos, random_vec) > 300 or hg.Dist(car_pos, random_vec) < 100:
+				turn_index = randint(0, len(track['pos']) - 1)
+				random_vec = track['pos'][turn_index]
+
+		track_vectors.append({'straight': track_straight, 'vector': random_vec,
+							  'turn_index': turn_index, 'lerp_value': lerp_value, 'track': track})
+
+	return track_vectors
+
+
+def HandleFakeCars(scene, res, nodes_track_data, local_pos, spawned_cars):
+	closest_node = None
+	closest_node_data = None
+
+	for nodes_data in nodes_track_data:
+		node = nodes_data['node']
+		if not closest_node:
+			closest_node = node
+			closest_node_data = nodes_data
+		else:
+			if hg.Dist(local_pos, node.GetTransform().GetPos()) < hg.Dist(local_pos, closest_node.GetTransform().GetPos()):
+				closest_node = node
+				closest_node_data = nodes_data
+
+	for car in spawned_cars:
+		if hg.Dist(
+				local_pos, car['node'].GetTransform().GetPos()) > 300:
+			car['node'].DestroyInstance()
+
+	spawned_cars = [car for car in spawned_cars if hg.Dist(
+		local_pos, car['node'].GetTransform().GetPos()) < 300]
+
+	if len(spawned_cars) < 6:
+		track_vectors = GetRandomVectorsOnTrack(closest_node_data, local_pos)
+		for track_vector in track_vectors:
+			pos = track_vector['vector']
+			node, _ = hg.CreateInstanceFromAssets(scene, hg.TranslationMat4(
+				pos), "vehicles/ai_vehicle/drivable_car.scn", res, hg.GetForwardPipelineInfo())
+			print("Just spawned a car at Vec3(" + str(pos.x) +
+				  ", " + str(pos.y) + ", " + str(pos.z) + ")")
+			spawned_cars
+			track_vector['node'] = node
+			spawned_cars.append(track_vector)
+
+	# for car in spawned_cars:
+
+
+	return spawned_cars
 
-def CreateNewCar(scene, res, pos):
-	node, _ = hg.CreateInstanceFromAssets(scene, hg.TranslationMat4(pos), "vehicles/ai_vehicle/drivable_car.scn", res, hg.GetForwardPipelineInfo())
-	return node
 
 def HandleCarMovement(carnode, physics):
 	carnode_transform = carnode.GetTransform()
@@ -13,24 +81,61 @@ def HandleCarMovement(carnode, physics):
 	car_pos.z += 0.65
 	carnode_transform.SetPos(car_pos)
 	# physics.NodeWake(carnode)
-
+
+
 def GetBlockTracks():
 	file_dir_out = "out/"
 	path = os.getcwd() + "/../tools/path_converter/" + file_dir_out
- 
+
 	files = []
-	
+
 	for r, d, f in os.walk(path):
 		for file in f:
-				files.append(os.path.join(r, file))
+			files.append(os.path.join(r, file))
 
 	final_data = {}
- 
+
 	for f in files:
 		with open(f, 'r') as json_file:
 			file_name = os.path.basename(f).replace(".json", "")
 			node_name = file_name.replace("_tracks", "")
 			data = json.loads(json_file.read())
 			final_data[node_name] = data
-
-	return final_data
+
+	return final_data
+
+
+def GetTrackDataByNode(scene, track_data):
+	node_track_data = []
+	scene_nodes = scene.GetNodes()
+	for node_idx in range(scene_nodes.size()):
+		node_name = scene_nodes.at(node_idx).GetName()
+		for k in track_data:
+			if node_name == k:
+				node_localized_tracks = []
+				node = scene_nodes.at(node_idx)
+				node_world = node.GetTransform().GetWorld()
+				for track in track_data[k]:
+					localized_track_data = {'id': track['id'], 'pos': []}
+					track_pos = track['pos']
+					for vec3 in track_pos:
+						localized_track_data['pos'].append(
+							node_world * hg.Vec3(vec3[0], vec3[1], vec3[2]))
+					node_localized_tracks.append(localized_track_data)
+				node_track_data.append(
+					{'node': node, 'id': node_idx, 'track_data': node_localized_tracks})
+
+	return node_track_data
+
+
+def DrawTrackData(node_track_data, opaque_view_id, vtx_line_layout, lines_program):
+	tracks = node_track_data['track_data']
+	for index, track in enumerate(tracks):
+		# index 123 roads in the same direction as driver
+		positions_list = track['pos']
+		current_index = 0
+		max_index = len(positions_list) - 1
+		for i in range(max_index):
+			DrawLine(positions_list[current_index], positions_list[current_index + 1],
+					 hg.Color.Green, opaque_view_id, vtx_line_layout, lines_program)
+			current_index += 1

app/gui.py

@@ -1,21 +1,23 @@
 import harfang as hg
 from utils import MetersPerSecondToKMH
 
-def DrawGui(res_x, res_y, dt, dts, car_vel, vid, debug_physic, car_pos, debug_car, control_keyboard):
+def DrawGui(res_x, res_y, dt, dts, car_vel, vid, debug_physic, car_pos, debug_car, control_keyboard, road_track):
 	hg.ImGuiBeginFrame(res_x, res_y, dt, hg.ReadMouse(), hg.ReadKeyboard())
 	hg.ImGuiBegin("Debug", True, hg.ImGuiWindowFlags_NoMove | hg.ImGuiWindowFlags_NoResize)
-	hg.ImGuiSetWindowSize("Debug", hg.Vec2(350, 180), hg.ImGuiCond_Once)
+	hg.ImGuiSetWindowSize("Debug", hg.Vec2(350, 200), hg.ImGuiCond_Once)
 	hg.ImGuiText("dt = " + str(round(dts, 4)))
 	hg.ImGuiText("speed = " + str(round(MetersPerSecondToKMH(hg.Len(car_vel)))) + " km/h")
 	hg.ImGuiText("car position = Vec3(" + str(round(car_pos.x, 4)) + ", " + str(round(car_pos.y, 4)) + ", " + str(round(car_pos.z, 4)) + ")")
 	was_clicked, debug_physic = hg.ImGuiCheckbox('Physic Debug', debug_physic)
 	was_clicked, debug_car = hg.ImGuiCheckbox('Car Debug', debug_car)
 	was_clicked, control_keyboard = hg.ImGuiCheckbox('Keyboard Control', control_keyboard)
+	was_clicked, road_track = hg.ImGuiCheckbox('Debug Road Tracks', road_track)
+
 
 	hg.ImGuiEnd()
 	hg.ImGuiEndFrame(vid)
 
-	return debug_physic, debug_car, control_keyboard
+	return debug_physic, debug_car, control_keyboard, road_track
 
 def DrawLine(pos_a, pos_b, line_color, vid, vtx_line_layout, line_shader):
 	vtx = hg.Vertices(vtx_line_layout, 2)

app/main.py

@@ -80,9 +80,7 @@ def CreateMaterial(ubc, orm):
 
 clocks = hg.SceneClocks()
 physics = hg.SceneBullet3Physics()
-car = CarModelCreate("Generic Car", "car", scene, physics, res, hg.Vec3(5, 1.5, 0), hg.Vec3(0, 0, 0))
-second_car = CreateNewCar(scene, res, hg.Vec3(3.5, 1, 10))
-third_car = CreateNewCar(scene, res, hg.Vec3(7.5, 1, 20))
+car = CarModelCreate("Generic Car", "car", scene, physics, res, hg.Vec3(5, 1.5, 1000), hg.Vec3(0, 0, 0))
 
 carlights = CarLightsCreate("car", scene)
 physics.SceneCreatePhysicsFromAssets(scene)
@@ -127,7 +125,10 @@ def CreateMaterial(ubc, orm):
 physics_debug = False
 car_debug = False
 control_keyboard = False
+track_visualization = False
 track_data = GetBlockTracks()
+nodes_track_data = GetTrackDataByNode(scene, track_data)
+spawned_cars = []
 
 scene_nodes = scene.GetNodes()
 for node_idx in range(scene_nodes.size()):
@@ -163,9 +164,7 @@ def CreateMaterial(ubc, orm):
 	CarLightsSetReverse(carlights, reverse)
 	CarLightsUpdate(carlights, scene, dt)
 	current_camera_node, camera_update = CarCameraUpdate(car_camera, scene, keyboard, dt, car_vel, render_mode)
-	HandleCarMovement(second_car, physics)
-	HandleCarMovement(third_car, physics)
-
+	spawned_cars = HandleFakeCars(scene, res, nodes_track_data, car_pos, spawned_cars)
 
 	# Scene updates
 	vid = 0  # keep track of the next free view id
@@ -185,9 +184,9 @@ def CreateMaterial(ubc, orm):
 			hg.SetViewTransform(vid, view_matrix, projection_matrix)
 			rs = hg.ComputeRenderState(hg.BM_Opaque, hg.DT_Disabled, hg.FC_Disabled)
 			physics.RenderCollision(vid, vtx_lines, lines_program, rs, 0)
-
+
+		opaque_view_id = hg.GetSceneForwardPipelinePassViewId(passId, hg.SFPP_Opaque)
 		if car_debug:
-			opaque_view_id = hg.GetSceneForwardPipelinePassViewId(passId, hg.SFPP_Opaque)
 			for line in car_lines:
 				DrawLine(line[0], line[1], line[2], opaque_view_id, vtx_line_layout, lines_program)
 			for i in range(4):
@@ -199,6 +198,22 @@ def CreateMaterial(ubc, orm):
 				else:
 					line_end_pos = wheel_rays_debug['ray_dir'] * wheel_rays_debug['ray_max_dist'] + ray_pos
 					DrawLine(ray_pos, line_end_pos, hg.Color.Red, opaque_view_id, vtx_line_layout, lines_program)
+
+		if track_visualization:
+			closest_node = None
+			closest_node_data = None
+
+			for nodes_data in nodes_track_data:
+				node = nodes_data['node']
+				if not closest_node:
+					closest_node = node
+					closest_node_data = nodes_data
+				else:
+					if hg.Dist(car_pos, node.GetTransform().GetPos()) < hg.Dist(car_pos, closest_node.GetTransform().GetPos()):
+						closest_node = node
+						closest_node_data = nodes_data
+
+			DrawTrackData(closest_node_data, opaque_view_id, vtx_line_layout, lines_program)
 
 	# EoF
 	if render_mode == "vr":
@@ -255,7 +270,7 @@ def CreateMaterial(ubc, orm):
 
 	if render_mode == "normal":
 		vid += 1
-		physics_debug, car_debug, control_keyboard = DrawGui(res_x, res_y, dt, dts, car_vel, vid, physics_debug, car_pos, car_debug, control_keyboard)
+		physics_debug, car_debug, control_keyboard, track_visualization = DrawGui(res_x, res_y, dt, dts, car_vel, vid, physics_debug, car_pos, car_debug, control_keyboard, track_visualization)
 
 	hg.Frame()
 	hg.UpdateWindow(win)