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 test_asset_loader():
default_config = PGDriveEnv.default_config()
world_config = default_config["pg_world_config"]
world_config.update({"use_render": False, "use_image": False, "debug": False})
world = PGWorld(config=world_config)
try:
world.clear_world()
initialize_asset_loader(world)
print(AssetLoader.asset_path)
print(AssetLoader.file_path("aaa"))
# print(AssetLoader.get_loader())
finally:
world.close_world()
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()
def __init__(self, config: dict = None):
# Setup config and Panda3d
self.pg_config = self.default_config()
if config is not None:
self.pg_config.update(config)
if self.pg_config["pstats"]:
# pstats debug provided by panda3d
loadPrcFileData("", "want-pstats 1")
loadPrcFileData("", "win-size {} {}".format(*self.pg_config["window_size"]))
# Setup onscreen render
if self.pg_config["use_render"]:
self.mode = RENDER_MODE_ONSCREEN
# Warning it may cause memory leak, Pand3d Official has fixed this in their master branch.
# You can enable it if your panda version is latest.
loadPrcFileData("", "threading-model Cull/Draw") # multi-thread render, accelerate simulation when evaluate
else:
if self.pg_config["use_image"]:
self.mode = RENDER_MODE_OFFSCREEN
else:
self.mode = RENDER_MODE_NONE
if is_mac() and (self.mode == RENDER_MODE_OFFSCREEN): # Mac don't support offscreen rendering
self.mode = RENDER_MODE_ONSCREEN
# Setup some debug options
if self.pg_config["headless_image"]:
# headless machine support
loadPrcFileData("", "load-display pandagles2")
if self.pg_config["debug"]:
# debug setting
PGWorld.DEBUG = True
_free_warning()
setup_logger(debug=True)
self.accept('1', self.toggleDebug)
self.accept('2', self.toggleWireframe)
self.accept('3', self.toggleTexture)
self.accept('4', self.toggleAnalyze)
else:
# only report fatal error when debug is False
_suppress_warning()
# a special debug mode
if self.pg_config["debug_physics_world"]:
self.accept('1', self.toggleDebug)
super(PGWorld, self).__init__(windowType=self.mode)
# Change window size at runtime if screen too small
assert int(self.pg_config["use_topdown"]) + int(self.pg_config["use_image"]) <= 1, (
"Only one of use_topdown and use_image options can be selected."
)
main_window_position = (0, 0)
if self.mode == RENDER_MODE_ONSCREEN:
loadPrcFileData("", "compressed-textures 1") # Default to compress
h = self.pipe.getDisplayHeight()
w = self.pipe.getDisplayWidth()
if self.pg_config["window_size"][0] > 0.9 * w or self.pg_config["window_size"][1] > 0.9 * h:
old_scale = self.pg_config["window_size"][0] / self.pg_config["window_size"][1]
new_w = int(min(0.9 * w, 0.9 * h * old_scale))
new_h = int(min(0.9 * h, 0.9 * w / old_scale))
self.pg_config["window_size"] = tuple([new_w, new_h])
from panda3d.core import WindowProperties
props = WindowProperties()
props.setSize(self.pg_config["window_size"][0], self.pg_config["window_size"][1])
self.win.requestProperties(props)
logging.warning(
"Since your screen is too small ({}, {}), we resize the window to {}.".format(
w, h, self.pg_config["window_size"]
)
)
main_window_position = (
(w - self.pg_config["window_size"][0]) / 2, (h - self.pg_config["window_size"][1]) / 2
)
self.highway_render = None
if self.pg_config["use_topdown"]:
self.highway_render = HighwayRender(self.pg_config["use_render"], main_window_position)
# screen scale factor
self.w_scale = max(self.pg_config["window_size"][0] / self.pg_config["window_size"][1], 1)
self.h_scale = max(self.pg_config["window_size"][1] / self.pg_config["window_size"][0], 1)
if self.mode == RENDER_MODE_ONSCREEN:
self.disableMouse()
if not self.pg_config["debug_physics_world"] and (self.mode in [RENDER_MODE_ONSCREEN, RENDER_MODE_OFFSCREEN]):
initialize_asset_loader(self)
gltf.patch_loader(self.loader)
# Display logo
if self.mode == RENDER_MODE_ONSCREEN:
self._loading_logo = OnscreenImage(
image=AssetLoader.file_path("PGDrive-large.png"),
pos=(0, 0, 0),
scale=(self.w_scale, 1, self.h_scale)
)
self._loading_logo.setTransparency(True)
for i in range(20):
self.graphicsEngine.renderFrame()
self.taskMgr.add(self.remove_logo, "remove _loading_logo in first frame")
self.closed = False
# add element to render and pbr render, if is exists all the time.
# these element will not be removed when clear_world() is called
self.pbr_render = self.render.attachNewNode("pbrNP")
# attach node to this root root whose children nodes will be clear after calling clear_world()
self.worldNP = self.render.attachNewNode("world_np")
# same as worldNP, but this node is only used for render gltf model with pbr material
self.pbr_worldNP = self.pbr_render.attachNewNode("pbrNP")
self.debug_node = None
# some render attr
self.pbrpipe = None
self.light = None
self.collision_info_np = None
# physics world
self.physics_world = PGPhysicsWorld()
# for real time simulation
self.force_fps = ForceFPS(self, start=False)
# init terrain
self.terrain = Terrain()
self.terrain.attach_to_pg_world(self.render, self.physics_world)
# init other world elements
if self.mode != RENDER_MODE_NONE:
from pgdrive.world.our_pbr import OurPipeline
self.pbrpipe = OurPipeline(
render_node=None,
window=None,
camera_node=None,
msaa_samples=4,
max_lights=8,
use_normal_maps=False,
use_emission_maps=True,
exposure=1.0,
enable_shadows=False,
enable_fog=False,
use_occlusion_maps=False
)
self.pbrpipe.render_node = self.pbr_render
self.pbrpipe.render_node.set_antialias(AntialiasAttrib.M_auto)
self.pbrpipe._recompile_pbr()
self.pbrpipe.manager.cleanup()
# set main cam
self.cam.node().setCameraMask(CamMask.MainCam)
self.cam.node().getDisplayRegion(0).setClearColorActive(True)
self.cam.node().getDisplayRegion(0).setClearColor(ImageBuffer.BKG_COLOR)
lens = self.cam.node().getLens()
lens.setFov(70)
lens.setAspectRatio(1.2)
self.sky_box = SkyBox()
self.sky_box.attach_to_pg_world(self.render, self.physics_world)
self.light = Light(self.pg_config)
self.light.attach_to_pg_world(self.render, self.physics_world)
self.render.setLight(self.light.direction_np)
self.render.setLight(self.light.ambient_np)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# ui and render property
if self.pg_config["show_fps"]:
self.setFrameRateMeter(True)
# onscreen message
self.on_screen_message = PGOnScreenMessage(
debug=self.DEBUG
) if self.mode == RENDER_MODE_ONSCREEN and self.pg_config["onscreen_message"] else None
self._show_help_message = False
self._episode_start_time = time.time()
self.accept("h", self.toggle_help_message)
self.accept("f", self.force_fps.toggle)
else:
self.on_screen_message = None
# task manager
self.taskMgr.remove('audioLoop')
