def __init__(self, pg_world: PGWorld, map_config: dict = None):
"""
Map can be stored and recover to save time when we access the map encountered before
"""
parent_node_path, pg_physics_world = pg_world.worldNP, pg_world.physics_world
self.config = self.default_config()
if map_config:
self.config.update(map_config)
self.film_size = (self.config["draw_map_resolution"],
self.config["draw_map_resolution"])
self.lane_width = self.config[self.LANE_WIDTH]
self.lane_num = self.config[self.LANE_NUM]
self.random_seed = self.config[self.SEED]
self.road_network = RoadNetwork()
self.blocks = []
generate_type = self.config[self.GENERATE_METHOD]
if generate_type == BigGenerateMethod.BLOCK_NUM or generate_type == BigGenerateMethod.BLOCK_SEQUENCE:
self._big_generate(parent_node_path, pg_physics_world)
elif generate_type == MapGenerateMethod.PG_MAP_FILE:
# other config such as lane width, num and seed will be valid, since they will be read from file
blocks_config = self.read_map(self.config[self.GENERATE_PARA])
self._config_generate(blocks_config, parent_node_path,
pg_physics_world)
else:
raise ValueError(
"Map can not be created by {}".format(generate_type))
# a trick to optimize performance
self.road_network.update_indices()
self.road_network.build_helper()
self._load_to_highway_render(pg_world)
def __init__(self, block_index: int, pre_block_socket: BlockSocket, global_network: RoadNetwork, random_seed):
super(Block, self).__init__(random_seed)
# block information
assert self.ID is not None, "Each Block must has its unique ID When define Block"
assert self.SOCKET_NUM is not None, "The number of Socket should be specified when define a new block"
if block_index == 0:
from pgdrive.scene_creator.blocks import FirstBlock
assert isinstance(self, FirstBlock), "only first block can use block index 0"
elif block_index < 0:
logging.debug("It is recommended that block index should > 1")
self._block_name = str(block_index) + self.ID
self.block_index = block_index
self.number_of_sample_trial = 0
# each block contains its own road network and a global network
self._global_network = global_network
self.block_network = RoadNetwork()
# used to spawn npc
self._reborn_roads = []
# own sockets, one block derives from a socket, but will have more sockets to connect other blocks
self._sockets = []
# used to connect previous blocks, save its info here
self._pre_block_socket = pre_block_socket
self.pre_block_socket_index = pre_block_socket.index
# a bounding box used to improve efficiency x_min, x_max, y_min, y_max
self.bounding_box = None
# used to create this block, but for first block it is nonsense
if block_index != 0:
self.positive_lanes = self._pre_block_socket.positive_road.get_lanes(self._global_network)
self.negative_lanes = self._pre_block_socket.negative_road.get_lanes(self._global_network)
self.positive_lane_num = len(self.positive_lanes)
self.negative_lane_num = len(self.negative_lanes)
self.positive_basic_lane = self.positive_lanes[-1] # most right or outside lane is the basic lane
self.negative_basic_lane = self.negative_lanes[-1] # most right or outside lane is the basic lane
self.lane_width = self.positive_basic_lane.width_at(0)
if self.render:
# render pre-load
self.road_texture = self.loader.loadTexture(AssetLoader.file_path("textures", "sci", "color.jpg"))
self.road_texture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
self.road_texture.setAnisotropicDegree(8)
self.road_normal = self.loader.loadTexture(AssetLoader.file_path("textures", "sci", "normal.jpg"))
self.ts_color = TextureStage("color")
self.ts_normal = TextureStage("normal")
self.side_texture = self.loader.loadTexture(AssetLoader.file_path("textures", "side_walk", "color.png"))
self.side_texture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
self.side_texture.setAnisotropicDegree(8)
self.side_normal = self.loader.loadTexture(AssetLoader.file_path("textures", "side_walk", "normal.png"))
self.side_walk = self.loader.loadModel(AssetLoader.file_path("models", "box.bam"))
def vis_big(debug: bool = False):
test = TestBlock(debug=debug)
test.cam.setPos(-200, -350, 2000)
initialize_asset_loader(test)
global_network = RoadNetwork()
big = BIG(2, 3.5, global_network, test.render, test.world, 888)
test.vis_big(big)
test.big.block_num = 40
# big.generate(BigGenerateMethod.BLOCK_NUM, 10)
test.run()
def __init__(self, pg_world: PGWorld, map_config: dict = None):
"""
Map can be stored and recover to save time when we access the map encountered before
"""
self.config = PGConfig(map_config)
self.film_size = (self.config["draw_map_resolution"],
self.config["draw_map_resolution"])
self.random_seed = self.config[self.SEED]
self.road_network = RoadNetwork()
# A flatten representation of blocks, might cause chaos in city-level generation.
self.blocks = []
# Generate map and insert blocks
self._generate(pg_world)
assert self.blocks, "The generate methods does not fill blocks!"
# a trick to optimize performance
self.road_network.after_init()
def vis_big(debug: bool = False, block_type_version="v1", random_seed=None):
test = TestBlock(debug=debug)
if block_type_version == "v1":
random_seed = random_seed or 888
test.cam.setPos(-200, -350, 2000)
elif block_type_version == "v2":
random_seed = random_seed or 333
test.cam.setPos(300, 400, 2000)
initialize_asset_loader(test)
global_network = RoadNetwork()
big = BIG(
2, 3.5, global_network, test.render, test.world, random_seed=random_seed, block_type_version=block_type_version
)
test.vis_big(big)
test.big.block_num = 40
# big.generate(BigGenerateMethod.BLOCK_NUM, 10)
test.run()
from pgdrive.scene_creator.blocks.bottleneck import Merge, Split
from pgdrive.scene_creator.blocks.first_block import FirstBlock
from pgdrive.scene_creator.road.road_network import RoadNetwork
from pgdrive.tests.vis_block.vis_block_base import TestBlock
from pgdrive.utils.asset_loader import initialize_asset_loader
if __name__ == "__main__":
test = TestBlock()
initialize_asset_loader(test)
global_network = RoadNetwork()
b = FirstBlock(global_network, 3.0, 1, test.render, test.world, 1)
for i in range(1, 13):
tp = Merge if i % 3 == 0 else Split
b = tp(i, b.get_socket(0), global_network, i)
b.construct_block(test.render, test.world)
test.show_bounding_box(global_network)
test.run()