def test_asset_loader():
default_config = PGDriveEnv.default_config()
world = EngineCore(global_config=default_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):
test = TestBlock(debug=debug)
test.cam.setPos(300, 400, 2000)
initialize_asset_loader(test)
set_global_random_seed(4)
global_network = RoadNetwork()
big = BIG(2, 3.5, global_network, test.render, test.world)
test.vis_big(big)
test.big.block_num = 40
# big.generate(BigGenerateMethod.BLOCK_NUM, 10)
test.run()
from pgdrive.component.blocks.first_block import FirstPGBlock
from pgdrive.component.blocks.std_intersection import StdInterSection
from pgdrive.component.blocks.std_t_intersection import StdTInterSection
from pgdrive.component.road.road_network import RoadNetwork
from pgdrive.tests.vis_block.vis_block_base import TestBlock
if __name__ == "__main__":
test = TestBlock()
from pgdrive.engine.asset_loader import initialize_asset_loader
initialize_asset_loader(test)
global_network = RoadNetwork()
first = FirstPGBlock(global_network, 3.0, 1, test.render, test.world, 1)
intersection = StdInterSection(3, first.get_socket(0), global_network, 1)
print(intersection.construct_block(test.render, test.world))
id = 4
for socket_idx in range(intersection.SOCKET_NUM):
block = StdTInterSection(id, intersection.get_socket(socket_idx),
global_network, id)
block.construct_block(test.render, test.world)
id += 1
test.show_bounding_box(global_network)
test.run()
def __init__(self, global_config):
self.global_config = global_config
if self.global_config["pstats"]:
# pstats debug provided by panda3d
loadPrcFileData("", "want-pstats 1")
loadPrcFileData(
"", "win-size {} {}".format(*self.global_config["window_size"]))
# Setup onscreen render
if self.global_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.global_config["offscreen_render"]:
self.mode = RENDER_MODE_OFFSCREEN
loadPrcFileData("", "threading-model Cull/Draw")
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.global_config["headless_machine_render"]:
# headless machine support
loadPrcFileData("", "load-display pandagles2")
if self.global_config["debug"]:
# debug setting
EngineCore.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.global_config["debug_physics_world"]:
self.accept('1', self.toggleDebug)
self.accept('4', self.toggleAnalyze)
super(EngineCore, self).__init__(windowType=self.mode)
# Change window size at runtime if screen too small
# assert int(self.global_config["use_topdown"]) + int(self.global_config["offscreen_render"]) <= 1, (
# "Only one of use_topdown and offscreen_render options can be selected."
# )
# main_window_position = (0, 0)
if self.mode == RENDER_MODE_ONSCREEN:
if self.global_config["fast"]:
pass
else:
loadPrcFileData("",
"compressed-textures 1") # Default to compress
h = self.pipe.getDisplayHeight()
w = self.pipe.getDisplayWidth()
if self.global_config["window_size"][
0] > 0.9 * w or self.global_config["window_size"][
1] > 0.9 * h:
old_scale = self.global_config["window_size"][
0] / self.global_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.global_config["window_size"] = tuple([new_w, new_h])
from panda3d.core import WindowProperties
props = WindowProperties()
props.setSize(self.global_config["window_size"][0],
self.global_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.global_config["window_size"]))
# main_window_position = (
# (w - self.global_config["window_size"][0]) / 2, (h - self.global_config["window_size"][1]) / 2
# )
# self.highway_render = None
# if self.global_config["use_topdown"]:
# self.highway_render = HighwayRender(self.global_config["use_render"], main_window_position)
# screen scale factor
self.w_scale = max(
self.global_config["window_size"][0] /
self.global_config["window_size"][1], 1)
self.h_scale = max(
self.global_config["window_size"][1] /
self.global_config["window_size"][0], 1)
if self.mode == RENDER_MODE_ONSCREEN:
self.disableMouse()
if not self.global_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 and (not self.global_config["debug"]) \
and (not self.global_config["fast"]):
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 attribute
self.pbrpipe = None
self.world_light = None
# physics world
self.physics_world = PhysicsWorld(
self.global_config["debug_static_world"])
# collision callback
self.physics_world.dynamic_world.setContactAddedCallback(
PythonCallbackObject(collision_callback))
# for real time simulation
self.force_fps = ForceFPS(self, start=True)
# init terrain
self.terrain = Terrain()
self.terrain.attach_to_world(self.render, self.physics_world)
# init other world elements
if self.mode != RENDER_MODE_NONE:
from pgdrive.engine.core.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(BKG_COLOR)
lens = self.cam.node().getLens()
lens.setFov(70)
lens.setAspectRatio(1.2)
self.sky_box = SkyBox()
self.sky_box.attach_to_world(self.render, self.physics_world)
self.world_light = Light(self.global_config)
self.world_light.attach_to_world(self.render, self.physics_world)
self.render.setLight(self.world_light.direction_np)
self.render.setLight(self.world_light.ambient_np)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# ui and render property
if self.global_config["show_fps"]:
self.setFrameRateMeter(True)
# onscreen message
self.on_screen_message = ScreenMessage(
debug=self.DEBUG
) if self.mode == RENDER_MODE_ONSCREEN and self.global_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')