def __init__(self):
ShowBase.__init__(self)
gltf.patch_loader(self.loader)
self.disable_mouse()
self.generateText()
self.defineKeys()
self.title = OnscreenText(text="Simulação do TCC",
fg=(1, 1, 1, 1), parent=self.a2dBottomRight,
align=TextNode.ARight, pos=(-0.1, 0.1),
shadow=(0, 0, 0, .5), scale=.08)
self.hand = Actor("models/Simple_Hand_AfterApply.gltf")
self.hand.reparentTo(self.render)
self.hand.setPos(0, 5, 0)
self.loadHandJoints()
self.taskMgr.add(self.setHandPostion, "HandTracking")
print(self.camera.getPos())
print(self.hand.getPos())
def init_mesh_loader():
if settings.use_assimp:
loadPrcFileData(
"", "load-file-type p3assimp\n"
"assimp-gen-normals #t\n"
"assimp-smooth-normal-angle 90\n")
if sys.version_info[0] >= 3:
gltf.patch_loader(None)
path = cache.create_path_for("models")
loadPrcFileData("", "model-cache-dir %s\n" % path)
def init(self):
self._render_lock = Lock()
try:
# There can be only 1 ShowBase instance at a time.
super().__init__(windowType="offscreen")
gltf.patch_loader(self.loader)
self.setBackgroundColor(0, 0, 0, 1)
# Displayed framerate is misleading since we are not using a realtime clock
self.setFrameRateMeter(False)
except Exception as e:
raise e
def init(self):
self._render_lock = Lock()
try:
# There can be only 1 ShowBase instance at a time.
super().__init__(windowType="offscreen")
gltf.patch_loader(self.loader)
self.setBackgroundColor(0, 0, 0, 1)
# Displayed framerate is misleading since we are not using a realtime clock
self.setFrameRateMeter(False)
except Exception as e:
# Known reasons for this failing:
raise RendererException(
f"Error in initializing framework for opening graphical display and creating scene graph. "
"A typical reason is display not found. Try running with different configurations of "
"`export DISPLAY=` using `:0`, `:1`... . If this does not work please consult "
"the documentation.\nException was: {e}") from e
def __init__(self):
if len(sys.argv) < 2:
print("Missing input file")
sys.exit(1)
super().__init__()
simplepbr.init()
gltf.patch_loader(self.loader)
infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1]))
p3d.get_model_path().prepend_directory(infile.get_dirname())
self.model_root = self.loader.load_model(infile, noCache=True)
self.accept('escape', sys.exit)
self.accept('q', sys.exit)
self.accept('w', self.toggle_wireframe)
self.accept('t', self.toggle_texture)
self.accept('shift-l', self.model_root.ls)
self.accept('shift-a', self.model_root.analyze)
if not self.model_root.find('**/+Light'):
self.light = self.render.attach_new_node(p3d.PointLight('light'))
self.light.set_pos(-5, 5, 5)
self.render.set_light(self.light)
self.cam.set_pos(-6, 6, 6)
self.cam.look_at(self.model_root)
self.model_root.reparent_to(self.render)
if self.model_root.find('**/+Character'):
self.anims = p3d.AnimControlCollection()
p3d.autoBind(self.model_root.node(), self.anims, ~0)
if self.anims.get_num_anims() > 0:
self.anims.get_anim(0).loop(True)
def __init__(self):
if len(sys.argv) < 2:
print("Missing input file")
sys.exit(1)
super().__init__()
self.setup_shaders(self.render)
gltf.patch_loader(self.loader)
infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1]))
p3d.get_model_path().prepend_directory(infile.get_dirname())
self.model_root = self.loader.load_model(infile)
self.accept('escape', sys.exit)
self.accept('q', sys.exit)
self.light = self.render.attach_new_node(p3d.PointLight('light'))
self.light.set_pos(-5, 5, 5)
self.render.set_light(self.light)
self.cam.set_pos(-10, 10, 10)
if self.model_root.find('**/+Character'):
self.actor = Actor(self.model_root)
self.actor.reparent_to(self.render)
anims = self.actor.get_anim_names()
if anims:
self.actor.loop(anims[0])
self.cam.look_at(self.actor)
else:
self.model_root.reparent_to(self.render)
self.cam.look_at(self.model_root)
def __init__(self,
body_props,
face_pos,
cam,
args,
pifpaf,
pose3d,
with_azure=False):
ShowBase.__init__(self)
# Set up Panda3d environment
self.disableMouse()
self.setBackgroundColor(0.5, 0.6, 0.9)
self.setupLights()
### initialize all the required variables ###
# set face and body proportions to construct the avatar
self.body_props = body_props
self.face_pos = face_pos
# set the input video capture
self.cam = cam
# initialise the predictive models
self.pifpaf = pifpaf
self.pose3d = pose3d
self.args = args
# moving average variables and parameters
self.buffer_counter = 0
self.buffer_size = 5
self.buffer = np.zeros((17, self.buffer_size))
#kinect azure boolean
self.with_azure = with_azure
# variables to estimate frame rate
self.iter_count = 0
self.frame_rate = 0
self.previous_time = time.time()
# error text initializing
if self.with_azure:
self.text = OnscreenText(text='my text string',
pos=(-0.5, 0.02),
scale=0.07)
# recording attributes
self.stored_vals = {
"azure": {
"head": [],
"back": [],
"orient": []
},
"pose3d": {
"head": [],
"back": [],
"orient": []
}
}
self.stored_kinect_data = []
self.stored_pifpaf = []
self.record_id = str(int(time.time()))
# create the folders to store the recorded results of the session
os.mkdir("posture-app/results/" + self.record_id)
os.mkdir("posture-app/results/" + self.record_id + "/images")
self.record_count = 0
self.is_recording = False
# initialize the angle dicts
angles = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, math.pi / 2, math.pi / 2,
math.pi / 2, 0, 0, 0, 0, 0, 0, 0, 0)
self.angle_dic = {
'head': angles[:3],
'back': angles[3:6],
'x': [angles[6]],
'y': [angles[7]],
'z': [angles[8]],
'left arm': angles[9:13],
'right arm': angles[13:]
}
self.azure_angle_dic = {}
# create the pose skeleton
self.create_pose(self.body_props, self.face_pos, self.angle_dic,
self.with_azure)
# necessary to read blender 3D objects
gltf.patch_loader(self.loader)
# adds the body part blender models to the skeleton
self.create_avatar()
# creates 3D points for each joints (used only for debugging angle conversions)
self.points = [Create3DPoint() for _ in range(21)]
# adds the update function as a thread to be called at every step of the game engine
self.taskMgr.add(self.update, "change_angles")
def __init__(
self,
agent_interfaces,
traffic_sim,
envision: EnvisionClient = None,
visdom: VisdomClient = None,
timestep_sec=0.1,
reset_agents_only=False,
zoo_workers=None,
auth_key=None,
):
try:
super().__init__(self, windowType="offscreen")
except Exception as e:
# Known reasons for this failing:
raise Exception(
"SMARTS: Error in initializing framework for opening graphical display and creating scene graph. "
"A typical reason is display not found. Try running with different configurations of "
"`export Display=` using `:0`, `:1`... . If this does not work please consult "
"the documentation."
) from e
gltf.patch_loader(self.loader)
self._log = logging.getLogger(self.__class__.__name__)
self._is_setup = False
self._scenario: Scenario = None
self._envision: EnvisionClient = envision
self._visdom: VisdomClient = visdom
self._timestep_sec = timestep_sec
self._traffic_sim = traffic_sim
self._motion_planner_provider = MotionPlannerProvider()
self._traffic_history_provider = TrafficHistoryProvider()
self._providers = [
self._traffic_sim,
self._motion_planner_provider,
self._traffic_history_provider,
]
# We buffer provider state between steps to compensate for TRACI's timestep delay
self._last_provider_state = None
self._reset_agents_only = reset_agents_only # a.k.a "teleportation"
self._imitation_learning_mode = False
# Global clock always proceeds by a fixed dt on each tick
self.taskMgr.clock.setMode(ClockObject.M_non_real_time)
self.taskMgr.clock.setDt(timestep_sec)
self._elapsed_sim_time = 0
self.setBackgroundColor(0, 0, 0, 1)
# Displayed framerate is misleading since we are not using a realtime clock
self.setFrameRateMeter(False)
# For macOS GUI. See our `BulletClient` docstring for details.
# from .utils.bullet import BulletClient
# self._bullet_client = BulletClient(pybullet.GUI)
self._bullet_client = bc.BulletClient(pybullet.DIRECT)
self._pybullet_action_spaces = {
ActionSpaceType.Continuous,
ActionSpaceType.Lane,
ActionSpaceType.ActuatorDynamic,
ActionSpaceType.LaneWithContinuousSpeed,
ActionSpaceType.Trajectory,
ActionSpaceType.MPC,
}
# Set up indices
self._agent_manager = AgentManager(agent_interfaces, zoo_workers, auth_key)
self._vehicle_index = VehicleIndex()
# TODO: Should not be stored in SMARTS
self._vehicle_collisions = defaultdict(list) # list of `Collision` instances
self._vehicle_states = []
self._bubble_manager = None
self._trap_manager: TrapManager = None
# SceneGraph-related setup
self._root_np = None
self._vehicles_np = None
self._road_network_np = None
self._ground_bullet_id = None
def __init__(self):
load_prc_file_data(
"", """
win-size 1920 1080
window-title Panda3D Arena Sample FPS Bullet Auto Colliders PBR HW Skinning
show-frame-rate-meter #t
framebuffer-srgb #t
framebuffer-multisample 1
multisamples 4
view-frustum-cull 0
textures-power-2 none
hardware-animated-vertices #t
gl-depth-zero-to-one true
clock-frame-rate 60
interpolate-frames 1
cursor-hidden #t
fullscreen #f
""")
# Initialize the showbase
super().__init__()
gltf.patch_loader(self.loader)
props = WindowProperties()
props.set_mouse_mode(WindowProperties.M_relative)
base.win.request_properties(props)
base.set_background_color(0.5, 0.5, 0.8)
self.camLens.set_fov(80)
self.camLens.set_near_far(0.01, 90000)
self.camLens.set_focal_length(7)
# self.camera.set_pos(0, 0, 2)
# ConfigVariableManager.getGlobalPtr().listVariables()
# point light generator
for x in range(0, 3):
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = self.render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20),
random.uniform(20, 21))
self.render.set_light(plight_1_node)
# point light for volumetric lighting filter
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = self.render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20), random.uniform(20, 21))
self.render.set_light(plight_1_node)
scene_filters = CommonFilters(base.win, base.cam)
scene_filters.set_bloom()
scene_filters.set_high_dynamic_range()
scene_filters.set_exposure_adjust(0.6)
scene_filters.set_gamma_adjust(1.1)
# scene_filters.set_volumetric_lighting(plight_1_node, 32, 0.5, 0.7, 0.1)
# scene_filters.set_blur_sharpen(0.9)
# scene_filters.set_ambient_occlusion(32, 0.05, 2.0, 0.01, 0.000002)
self.accept("f3", self.toggle_wireframe)
self.accept("escape", sys.exit, [0])
exponential_fog = Fog('world_fog')
exponential_fog.set_color(0.6, 0.7, 0.7)
# this is a very low fog value, set it higher for a greater effect
exponential_fog.set_exp_density(0.00009)
self.render.set_fog(exponential_fog)
self.game_start = 0
from panda3d.bullet import BulletWorld
from panda3d.bullet import BulletCharacterControllerNode
from panda3d.bullet import ZUp
from panda3d.bullet import BulletCapsuleShape
from panda3d.bullet import BulletTriangleMesh
from panda3d.bullet import BulletTriangleMeshShape
from panda3d.bullet import BulletBoxShape
from panda3d.bullet import BulletGhostNode
from panda3d.bullet import BulletRigidBodyNode
from panda3d.bullet import BulletPlaneShape
self.world = BulletWorld()
self.world.set_gravity(Vec3(0, 0, -9.81))
arena_1 = self.loader.load_model('models/arena_1.gltf')
arena_1.reparent_to(self.render)
arena_1.set_pos(0, 0, 0)
def make_collision_from_model(input_model, node_number, mass, world,
target_pos, h_adj):
# tristrip generation from static models
# generic tri-strip collision generator begins
geom_nodes = input_model.find_all_matches('**/+GeomNode')
geom_nodes = geom_nodes.get_path(node_number).node()
# print(geom_nodes)
geom_target = geom_nodes.get_geom(0)
# print(geom_target)
output_bullet_mesh = BulletTriangleMesh()
output_bullet_mesh.add_geom(geom_target)
tri_shape = BulletTriangleMeshShape(output_bullet_mesh,
dynamic=False)
print(output_bullet_mesh)
body = BulletRigidBodyNode('input_model_tri_mesh')
np = self.render.attach_new_node(body)
np.node().add_shape(tri_shape)
np.node().set_mass(mass)
np.node().set_friction(0.01)
np.set_pos(target_pos)
np.set_scale(1)
np.set_h(h_adj)
# np.set_p(180)
# np.set_r(180)
np.set_collide_mask(BitMask32.allOn())
world.attach_rigid_body(np.node())
make_collision_from_model(arena_1, 0, 0, self.world,
(arena_1.get_pos()), 0)
# load the scene shader
scene_shader = Shader.load(Shader.SL_GLSL,
"shaders/simplepbr_vert_mod_1.vert",
"shaders/simplepbr_frag_mod_1.frag")
self.render.set_shader(scene_shader)
self.render.set_antialias(AntialiasAttrib.MMultisample)
scene_shader_attrib = ShaderAttrib.make(scene_shader)
scene_shader_attrib = scene_shader_attrib.setFlag(
ShaderAttrib.F_hardware_skinning, True)
# initialize player character physics the Bullet way
shape_1 = BulletCapsuleShape(0.75, 0.5, ZUp)
player_node = BulletCharacterControllerNode(
shape_1, 0.1, 'Player') # (shape, mass, player name)
# player_node.set_max_slope(0.1)
# player_node.set_linear_movement(1, True)
player_np = self.render.attach_new_node(player_node)
player_np.set_pos(-20, -10, 10)
player_np.set_collide_mask(BitMask32.allOn())
self.world.attach_character(player_np.node())
# cast player_np to self.player
self.player = player_np
# reparent player character to render node
fp_character = actor_data.player_character
fp_character.reparent_to(self.render)
fp_character.set_scale(1)
# set the actor skinning hardware shader
fp_character.set_attrib(scene_shader_attrib)
self.camera.reparent_to(self.player)
# reparent character to FPS cam
fp_character.reparent_to(self.player)
fp_character.set_pos(0, 0, -0.95)
# self.camera.set_x(self.player, 1)
self.camera.set_y(self.player, 0.03)
self.camera.set_z(self.player, 0.5)
# player gun begins
self.player_gun = actor_data.arm_handgun
self.player_gun.reparent_to(self.render)
self.player_gun.reparent_to(self.camera)
self.player_gun.set_x(self.camera, 0.1)
self.player_gun.set_y(self.camera, 0.4)
self.player_gun.set_z(self.camera, -0.1)
# directly make a text node to display text
text_1 = TextNode('text_1_node')
text_1.set_text("")
text_1_node = self.aspect2d.attach_new_node(text_1)
text_1_node.set_scale(0.05)
text_1_node.set_pos(-1.4, 0, 0.92)
# import font and set pixels per unit font quality
nunito_font = loader.load_font('fonts/Nunito/Nunito-Light.ttf')
nunito_font.set_pixels_per_unit(100)
nunito_font.set_page_size(512, 512)
# apply font
text_1.set_font(nunito_font)
# small caps
# text_1.set_small_caps(True)
# on-screen target dot for aiming
target_dot = TextNode('target_dot_node')
target_dot.set_text(".")
target_dot_node = self.aspect2d.attach_new_node(target_dot)
target_dot_node.set_scale(0.075)
target_dot_node.set_pos(0, 0, 0)
# target_dot_node.hide()
# apply font
target_dot.set_font(nunito_font)
target_dot.set_align(TextNode.ACenter)
# see the Task section for relevant dot update logic
# directly make a text node to display text
text_2 = TextNode('text_2_node')
text_2.set_text("Neutralize the NPC by shooting the head." + '\n' +
"Press 'f' to toggle the flashlight.")
text_2_node = self.aspect2d.attach_new_node(text_2)
text_2_node.set_scale(0.04)
text_2_node.set_pos(-1.4, 0, 0.8)
# import font and set pixels per unit font quality
nunito_font = self.loader.load_font('fonts/Nunito/Nunito-Light.ttf')
nunito_font.set_pixels_per_unit(100)
nunito_font.set_page_size(512, 512)
# apply font
text_2.set_font(nunito_font)
text_2.set_text_color(0, 0.3, 1, 1)
# print player position on mouse click
def print_player_pos():
print(self.player.get_pos())
self.player.node().do_jump()
self.accept('mouse3', print_player_pos)
self.flashlight_state = 0
def toggle_flashlight():
current_flashlight = self.render.find_all_matches("**/flashlight")
if self.flashlight_state == 0:
if len(current_flashlight) == 0:
self.slight = 0
self.slight = Spotlight('flashlight')
self.slight.set_shadow_caster(True, 1024, 1024)
self.slight.set_color(VBase4(0.5, 0.6, 0.6,
1)) # slightly bluish
lens = PerspectiveLens()
lens.set_near_far(0.5, 5000)
self.slight.set_lens(lens)
self.slight.set_attenuation((0.5, 0, 0.0000005))
self.slight = self.render.attach_new_node(self.slight)
self.slight.set_pos(-0.1, 0.3, -0.4)
self.slight.reparent_to(self.camera)
self.flashlight_state = 1
self.render.set_light(self.slight)
elif len(current_flashlight) > 0:
self.render.set_light(self.slight)
self.flashlight_state = 1
elif self.flashlight_state > 0:
self.render.set_light_off(self.slight)
self.flashlight_state = 0
self.accept('f', toggle_flashlight)
# add a few random physics boxes
for x in range(0, 40):
# dynamic collision
random_vec = Vec3(1, 1, 1)
special_shape = BulletBoxShape(random_vec)
# rigidbody
body = BulletRigidBodyNode('random_prisms')
d_coll = self.render.attach_new_node(body)
d_coll.node().add_shape(special_shape)
d_coll.node().set_mass(0.9)
d_coll.node().set_friction(0.5)
d_coll.set_collide_mask(BitMask32.allOn())
# turn on Continuous Collision Detection
d_coll.node().set_ccd_motion_threshold(0.000000007)
d_coll.node().set_ccd_swept_sphere_radius(0.30)
d_coll.node().set_deactivation_enabled(False)
d_coll.set_pos(random.uniform(-60, -20), random.uniform(-60, -20),
random.uniform(5, 10))
box_model = self.loader.load_model('models/1m_cube.gltf')
box_model.reparent_to(self.render)
box_model.reparent_to(d_coll)
box_model.set_color(random.uniform(0, 1), random.uniform(0, 1),
random.uniform(0, 1), 1)
self.world.attach_rigid_body(d_coll.node())
# portal #1 begins
# make a new texture buffer, render node, and attach a camera
mirror_buffer = self.win.make_texture_buffer("mirror_buff", 4096, 4096)
mirror_render = NodePath("mirror_render")
mirror_render.set_shader(scene_shader)
self.mirror_cam = self.make_camera(mirror_buffer)
self.mirror_cam.reparent_to(mirror_render)
self.mirror_cam.set_pos(0, -60, 5)
self.mirror_cam.set_hpr(0, 25, 0)
self.mirror_cam.node().get_lens().set_focal_length(10)
self.mirror_cam.node().get_lens().set_fov(90)
mirror_filters = CommonFilters(mirror_buffer, self.mirror_cam)
# mirror_filters.set_high_dynamic_range()
mirror_filters.set_exposure_adjust(1.1)
# mirror_filters.set_gamma_adjust(1.3)
# load in a mirror/display object model in normal render space
self.mirror_model = self.loader.loadModel(
'models/wide_screen_video_display.egg')
self.mirror_model.reparent_to(self.render)
self.mirror_model.set_pos(-20, 0, 1)
self.mirror_model.set_sz(3)
# self.mirror_model.flatten_strong()
# mirror scene model load-in
# reparent to mirror render node
house_uv = self.loader.load_model('models/hangar_1.gltf')
house_uv.reparent_to(mirror_render)
windows = house_uv.find('**/clear_arches')
windows.hide()
house_uv.set_pos(0, 0, 0)
house_uv.set_scale(1)
# the portal ramp
house_uv = self.loader.load_model('models/ramp_1.gltf')
house_uv.reparent_to(mirror_render)
house_uv.set_h(180)
house_uv.set_scale(1.5)
house_uv.set_pos(0, -50, 0)
# mirror scene lighting
# point light generator
for x in range(0, 1):
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = mirror_render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20),
random.uniform(20, 21))
mirror_render.set_light(plight_1_node)
# set the live buffer texture to the mirror/display model in normal render space
self.mirror_model.set_texture(mirror_buffer.get_texture())
# secret hangar far off somewhere on the graph
house_uv = self.loader.load_model('models/hangar_1.gltf')
house_uv.reparent_to(self.render)
windows = house_uv.find('**/clear_arches')
windows.hide()
house_uv.set_pos(400, 400, -1)
# the portal ring
house_uv = self.loader.load_model('models/ring_1.gltf')
house_uv.reparent_to(self.render)
house_uv.set_h(90)
house_uv.set_pos(-20, 0, -2)
# the portal ramp
house_uv = self.loader.load_model('models/ramp_1.gltf')
house_uv.reparent_to(self.render)
house_uv.set_h(0)
house_uv.set_pos(-20, -5.5, 0)
r_pos = house_uv.get_pos()
make_collision_from_model(house_uv, 0, 0, self.world,
(r_pos[0], r_pos[1], r_pos[2] + 1), 0)
self.count_frames_1 = 0
self.screen_cap_num = 1
def make_screenshot():
# Ensure the frame is rendered.
base.graphicsEngine.render_frame()
# Grab the screenshot into a big image
full = PNMImage()
base.win.get_screenshot(full)
# Now reduce it
reduced = PNMImage(500, 300)
reduced.gaussianFilterFrom(1, full)
# And write it out.
reduced.write(
Filename('screen_cap_' + str(self.screen_cap_num) + '.jpg'))
self.screen_cap_num += 1
def update_portal_cam(Task):
if self.count_frames_1 < 30:
self.count_frames_1 += 1
if self.count_frames_1 == 15:
pass
# make_screenshot()
if self.count_frames_1 == 29:
self.count_frames_1 = 0
p_dist = (self.player.get_pos() -
self.mirror_model.get_pos(base.render)).length()
target_fov = 115
if p_dist < 2.25:
target_fov = 145
self.player.set_pos(400, 400, 3)
# adjust the ground plane
self.ground_plane.set_pos(0, 0, 0)
# move the normal point lights
lights = self.render.find_all_matches('**/plight*')
for l in lights:
l.set_pos(400, 400, 21)
player_h = self.player.get_h()
self.mirror_cam.set_h(player_h)
self.mirror_cam.node().get_lens().set_fov(target_fov)
return Task.cont
self.task_mgr.add(update_portal_cam)
# portal #2 begins
# the portal ring
house_uv = self.loader.load_model('models/ring_1.gltf')
house_uv.reparent_to(self.render)
house_uv.set_h(90)
house_uv.set_pos(400, 400, -2)
# the portal ramp
house_uv = self.loader.load_model('models/ramp_1.gltf')
house_uv.reparent_to(self.render)
house_uv.set_h(180)
house_uv.set_pos(400, 405.5, 0)
r_pos = house_uv.get_pos()
make_collision_from_model(house_uv, 0, 0, self.world,
(r_pos[0], r_pos[1], r_pos[2] + 1), 180)
# NPC_1 load-in
comp_shape_1 = BulletCapsuleShape(0.05, 0.01, ZUp)
npc_1_node = BulletCharacterControllerNode(
comp_shape_1, 0.2, 'NPC_A_node') # (shape, mass, character name)
np = self.render.attach_new_node(npc_1_node)
np.set_pos(-40, -40, 5)
np.set_collide_mask(BitMask32.allOn())
self.world.attach_character(np.node())
np.set_h(random.randint(0, 180))
npc_model_1 = actor_data.NPC_1
npc_model_1.reparent_to(np)
# set the actor skinning hardware shader
npc_model_1.set_attrib(scene_shader_attrib)
# get the separate head model
npc_1_head = self.loader.load_model('models/npc_1_head.gltf')
npc_1_head.reparent_to(actor_data.NPC_1.get_parent())
# npc base animation loop
npc_1_control = actor_data.NPC_1.get_anim_control('walking')
if not npc_1_control.is_playing():
actor_data.NPC_1.stop()
actor_data.NPC_1.loop("walking", fromFrame=60, toFrame=180)
actor_data.NPC_1.set_play_rate(6.0, 'walking')
# create special hit areas
# use Task section for npc collision movement logic
# special head node size
special_shape = BulletBoxShape(Vec3(0.1, 0.1, 0.1))
# ghost npc node
body = BulletGhostNode('special_node_A')
special_node = self.render.attach_new_node(body)
special_node.node().add_shape(
special_shape, TransformState.makePos(Point3(0, 0, 0.4)))
# special_node.node().set_mass(0)
# special_node.node().set_friction(0.5)
special_node.set_collide_mask(BitMask32(0x0f))
# turn on Continuous Collision Detection
special_node.node().set_deactivation_enabled(False)
special_node.node().set_ccd_motion_threshold(0.000000007)
special_node.node().set_ccd_swept_sphere_radius(0.30)
self.world.attach_ghost(special_node.node())
# dynamic collision
special_shape = BulletBoxShape(Vec3(0.3, 0.15, 0.6))
# rigidbody npc node
body = BulletRigidBodyNode('d_coll_A')
d_coll = self.render.attach_new_node(body)
d_coll.node().add_shape(special_shape,
TransformState.makePos(Point3(0, 0, 0.7)))
# d_coll.node().set_mass(0)
d_coll.node().set_friction(0.5)
d_coll.set_collide_mask(BitMask32.allOn())
# turn on Continuous Collision Detection
d_coll.node().set_deactivation_enabled(False)
d_coll.node().set_ccd_motion_threshold(0.000000007)
d_coll.node().set_ccd_swept_sphere_radius(0.30)
self.world.attach_rigid_body(d_coll.node())
# npc state variables
self.npc_1_is_dead = False
self.npc_1_move_increment = Vec3(0, 0, 0)
self.gun_anim_is_playing = False
# npc movement timer
def npc_1_move_gen():
while not self.npc_1_is_dead:
m_incs = []
for x in range(0, 2):
m_incs.append(random.uniform(2, 5))
print('NPC_1 movement increments this cycle: ' + str(m_incs))
self.npc_1_move_increment[0] = m_incs[0]
self.npc_1_move_increment[1] = m_incs[1]
time.sleep(3)
self.npc_1_move_increment[0] = m_incs[0]
self.npc_1_move_increment[1] = m_incs[1]
time.sleep(3)
self.npc_1_move_increment[0] = (-1 * m_incs[0]) * 2
self.npc_1_move_increment[1] = (-1 * m_incs[1]) * 2
time.sleep(3)
self.npc_1_move_increment[0] = 0
self.npc_1_move_increment[1] = 0
# activate the movement timer in a dedicated thread to prevent lockup with .sleep()
threading2._start_new_thread(npc_1_move_gen, ())
def is_npc_1_shot():
# animate the gun
gun_ctrl = actor_data.arm_handgun.get_anim_control('shoot')
if not gun_ctrl.is_playing():
actor_data.arm_handgun.stop()
actor_data.arm_handgun.play("shoot")
actor_data.arm_handgun.set_play_rate(15.0, 'shoot')
# target dot ray test
# get mouse data
mouse_watch = base.mouseWatcherNode
if mouse_watch.has_mouse():
posMouse = base.mouseWatcherNode.get_mouse()
posFrom = Point3()
posTo = Point3()
base.camLens.extrude(posMouse, posFrom, posTo)
posFrom = self.render.get_relative_point(base.cam, posFrom)
posTo = self.render.get_relative_point(base.cam, posTo)
rayTest = self.world.ray_test_closest(posFrom, posTo)
target = rayTest.get_node()
target_dot = self.aspect2d.find_all_matches(
"**/target_dot_node")
if 'special_node_A' in str(target):
def npc_cleanup():
# the head is hit, the npc is dead
self.npc_1_is_dead = True
text_2.set_text('Congrats, you have won!')
npc_1_control = actor_data.NPC_1.get_anim_control(
'walking')
if npc_1_control.is_playing():
actor_data.NPC_1.stop()
npc_1_control = actor_data.NPC_1.get_anim_control(
'death')
if not npc_1_control.is_playing():
actor_data.NPC_1.play('death')
# Bullet node removals
self.world.remove(target)
rigid_target = self.render.find('**/d_coll_A')
self.world.remove(rigid_target.node())
threading2._start_new_thread(npc_cleanup, ())
self.accept('mouse1', is_npc_1_shot)
def smooth_load_physics():
# this is a patch to speed up the cold start hitch on success condition
# Bullet node removals
self.world.remove(special_node.node())
rigid_target = self.render.find('**/d_coll_A')
self.world.remove(rigid_target.node())
print('NPC physics init removed.')
smooth_load_physics()
# repeat the NPC physics initialization after smooth_load_physics
# create special hit areas
# use Task section for npc collision movement logic
# special head node size
special_shape = BulletBoxShape(Vec3(0.1, 0.1, 0.1))
# ghost npc node
body = BulletGhostNode('special_node_A')
special_node = self.render.attach_new_node(body)
special_node.node().add_shape(
special_shape, TransformState.makePos(Point3(0, 0, 0.4)))
# special_node.node().set_mass(0)
# special_node.node().set_friction(0.5)
special_node.set_collide_mask(BitMask32(0x0f))
# turn on Continuous Collision Detection
special_node.node().set_deactivation_enabled(False)
special_node.node().set_ccd_motion_threshold(0.000000007)
special_node.node().set_ccd_swept_sphere_radius(0.30)
self.world.attach_ghost(special_node.node())
# dynamic collision
special_shape = BulletBoxShape(Vec3(0.3, 0.15, 0.6))
# rigidbody npc node
body = BulletRigidBodyNode('d_coll_A')
d_coll = self.render.attach_new_node(body)
d_coll.node().add_shape(special_shape,
TransformState.makePos(Point3(0, 0, 0.7)))
# d_coll.node().set_mass(0)
d_coll.node().set_friction(0.5)
d_coll.set_collide_mask(BitMask32.allOn())
# turn on Continuous Collision Detection
d_coll.node().set_deactivation_enabled(False)
d_coll.node().set_ccd_motion_threshold(0.000000007)
d_coll.node().set_ccd_swept_sphere_radius(0.30)
self.world.attach_rigid_body(d_coll.node())
# 3D player movement system begins
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"run": 0,
"jump": 0
}
def setKey(key, value):
self.keyMap[key] = value
# define button map
self.accept("a", setKey, ["left", 1])
self.accept("a-up", setKey, ["left", 0])
self.accept("d", setKey, ["right", 1])
self.accept("d-up", setKey, ["right", 0])
self.accept("w", setKey, ["forward", 1])
self.accept("w-up", setKey, ["forward", 0])
self.accept("s", setKey, ["backward", 1])
self.accept("s-up", setKey, ["backward", 0])
self.accept("shift", setKey, ["run", 1])
self.accept("shift-up", setKey, ["run", 0])
self.accept("space", setKey, ["jump", 1])
self.accept("space-up", setKey, ["jump", 0])
# disable mouse
self.disable_mouse()
# the player movement speed
self.movementSpeedForward = 5
self.movementSpeedBackward = 5
self.dropSpeed = -0.2
self.striveSpeed = 6
self.ease = -10.0
self.static_pos_bool = False
self.static_pos = Vec3()
def move(Task):
if self.game_start > 0:
if not self.npc_1_is_dead:
npc_pos_1 = actor_data.NPC_1.get_parent().get_pos()
# place head hit box
special_node.set_pos(npc_pos_1[0], npc_pos_1[1],
npc_pos_1[2] + 1)
special_node.set_h(actor_data.NPC_1.get_h())
# dynamic collision node
d_coll.set_pos(npc_pos_1[0], npc_pos_1[1], npc_pos_1[2])
d_coll.set_h(actor_data.NPC_1.get_h())
# make the npc look at the player continuously
actor_data.NPC_1.look_at(self.player)
npc_1_head.look_at(self.player)
if actor_data.NPC_1.get_p() > 3:
actor_data.NPC_1.set_p(3)
if npc_1_head.get_p() > 3:
npc_1_head.set_p(3)
m_inst = self.npc_1_move_increment
t_inst = globalClock.get_dt()
actor_data.NPC_1.get_parent().set_pos(
npc_pos_1[0] + (m_inst[0] * t_inst),
npc_pos_1[1] + (m_inst[1] * t_inst), npc_pos_1[2])
if self.npc_1_is_dead:
npc_1_head.hide()
inst_h = actor_data.NPC_1.get_h()
inst_p = actor_data.NPC_1.get_p()
actor_data.NPC_1.set_hpr(inst_h, inst_p, 0)
# target dot ray test
# turns the target dot red
# get mouse data
mouse_watch = base.mouseWatcherNode
if mouse_watch.has_mouse():
posMouse = base.mouseWatcherNode.get_mouse()
posFrom = Point3()
posTo = Point3()
base.camLens.extrude(posMouse, posFrom, posTo)
posFrom = self.render.get_relative_point(base.cam, posFrom)
posTo = self.render.get_relative_point(base.cam, posTo)
rayTest = self.world.ray_test_closest(posFrom, posTo)
target = rayTest.get_node()
target_dot = self.aspect2d.find_all_matches(
"**/target_dot_node")
if 'special_node_A' in str(target):
# the npc is recognized, make the dot red
for dot in target_dot:
dot.node().set_text_color(0.9, 0.1, 0.1, 1)
if 'd_coll_A' in str(target):
# the npc is recognized, make the dot red
for dot in target_dot:
dot.node().set_text_color(0.9, 0.1, 0.1, 1)
if 'special_node_A' not in str(target):
# no npc recognized, make the dot white
if 'd_coll_A' not in str(target):
for dot in target_dot:
dot.node().set_text_color(1, 1, 1, 1)
# get mouse data
mouse_watch = base.mouseWatcherNode
if mouse_watch.has_mouse():
pointer = base.win.get_pointer(0)
mouseX = pointer.get_x()
mouseY = pointer.get_y()
# screen sizes
window_Xcoord_halved = base.win.get_x_size() // 2
window_Ycoord_halved = base.win.get_y_size() // 2
# mouse speed
mouseSpeedX = 0.2
mouseSpeedY = 0.2
# maximum and minimum pitch
maxPitch = 90
minPitch = -50
# cam view target initialization
camViewTarget = LVecBase3f()
if base.win.movePointer(0, window_Xcoord_halved,
window_Ycoord_halved):
p = 0
if mouse_watch.has_mouse():
# calculate the pitch of camera
p = self.camera.get_p() - (
mouseY - window_Ycoord_halved) * mouseSpeedY
# sanity checking
if p < minPitch:
p = minPitch
elif p > maxPitch:
p = maxPitch
if mouse_watch.has_mouse():
# directly set the camera pitch
self.camera.set_p(p)
camViewTarget.set_y(p)
# rotate the self.player's heading according to the mouse x-axis movement
if mouse_watch.has_mouse():
h = self.player.get_h() - (
mouseX - window_Xcoord_halved) * mouseSpeedX
if mouse_watch.has_mouse():
# sanity checking
if h < -360:
h += 360
elif h > 360:
h -= 360
self.player.set_h(h)
camViewTarget.set_x(h)
# hide the gun if looking straight down
if p < -30:
self.player_gun.hide()
if p > -30:
self.player_gun.show()
if self.keyMap["left"]:
if self.static_pos_bool:
self.static_pos_bool = False
self.player.set_x(self.player,
-self.striveSpeed * globalClock.get_dt())
myAnimControl = actor_data.player_character.get_anim_control(
'walking')
if not myAnimControl.isPlaying():
actor_data.player_character.play("walking")
actor_data.player_character.set_play_rate(
4.0, 'walking')
if not self.keyMap["left"]:
if not self.static_pos_bool:
self.static_pos_bool = True
self.static_pos = self.player.get_pos()
self.player.set_x(self.static_pos[0])
self.player.set_y(self.static_pos[1])
self.player.set_z(self.player,
self.dropSpeed * globalClock.get_dt())
if self.keyMap["right"]:
if self.static_pos_bool:
self.static_pos_bool = False
self.player.set_x(self.player,
self.striveSpeed * globalClock.get_dt())
myAnimControl = actor_data.player_character.get_anim_control(
'walking')
if not myAnimControl.isPlaying():
actor_data.player_character.play("walking")
actor_data.player_character.set_play_rate(
4.0, 'walking')
if not self.keyMap["right"]:
if not self.static_pos_bool:
self.static_pos_bool = True
self.static_pos = self.player.get_pos()
self.player.set_x(self.static_pos[0])
self.player.set_y(self.static_pos[1])
self.player.set_z(self.player,
self.dropSpeed * globalClock.get_dt())
if self.keyMap["forward"]:
if self.static_pos_bool:
self.static_pos_bool = False
self.player.set_y(
self.player,
self.movementSpeedForward * globalClock.get_dt())
myAnimControl = actor_data.player_character.get_anim_control(
'walking')
if not myAnimControl.isPlaying():
actor_data.player_character.play("walking")
actor_data.player_character.set_play_rate(
4.0, 'walking')
if self.keyMap["forward"] != 1:
if not self.static_pos_bool:
self.static_pos_bool = True
self.static_pos = self.player.get_pos()
self.player.set_x(self.static_pos[0])
self.player.set_y(self.static_pos[1])
self.player.set_z(self.player,
self.dropSpeed * globalClock.get_dt())
if self.keyMap["backward"]:
if self.static_pos_bool:
self.static_pos_bool = False
self.player.set_y(
self.player,
-self.movementSpeedBackward * globalClock.get_dt())
myBackControl = actor_data.player_character.get_anim_control(
'walking')
if not myBackControl.isPlaying():
myBackControl.stop()
actor_data.player_character.play('walking')
actor_data.player_character.set_play_rate(
-4.0, 'walking')
return Task.cont
# infinite ground plane
# the effective world-Z limit
ground_plane = BulletPlaneShape(Vec3(0, 0, 1), 0)
node = BulletRigidBodyNode('ground')
node.add_shape(ground_plane)
node.set_friction(0.1)
self.ground_plane = self.render.attach_new_node(node)
self.ground_plane.set_pos(0, 0, -1)
self.world.attach_rigid_body(node)
# Bullet debugger
from panda3d.bullet import BulletDebugNode
debugNode = BulletDebugNode('Debug')
debugNode.show_wireframe(True)
debugNode.show_constraints(True)
debugNode.show_bounding_boxes(False)
debugNode.show_normals(False)
debugNP = self.render.attach_new_node(debugNode)
self.world.set_debug_node(debugNP.node())
# debug toggle function
def toggle_debug():
if debugNP.is_hidden():
debugNP.show()
else:
debugNP.hide()
self.accept('f1', toggle_debug)
def update(Task):
if self.game_start < 1:
self.game_start = 1
return Task.cont
def physics_update(Task):
dt = globalClock.get_dt()
self.world.do_physics(dt)
return Task.cont
self.task_mgr.add(move)
self.task_mgr.add(update)
self.task_mgr.add(physics_update)
def __init__(self):
if len(sys.argv) < 2:
print("Missing input file")
sys.exit(1)
super().__init__()
self.pipeline = simplepbr.init()
gltf.patch_loader(self.loader)
infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1]))
p3d.get_model_path().prepend_directory(infile.get_dirname())
self.model_root = self.loader.load_model(infile, noCache=True)
self.accept('escape', sys.exit)
self.accept('q', sys.exit)
self.accept('w', self.toggle_wireframe)
self.accept('t', self.toggle_texture)
self.accept('n', self.toggle_normal_maps)
self.accept('e', self.toggle_emission_maps)
self.accept('o', self.toggle_occlusion_maps)
self.accept('a', self.toggle_ambient_light)
self.accept('shift-l', self.model_root.ls)
self.accept('shift-a', self.model_root.analyze)
self.model_root.reparent_to(self.render)
bounds = self.model_root.getBounds()
center = bounds.get_center()
if bounds.is_empty():
radius = 1
else:
radius = bounds.get_radius()
fov = self.camLens.get_fov()
distance = radius / math.tan(math.radians(min(fov[0], fov[1]) / 2.0))
self.camLens.set_near(min(self.camLens.get_default_near(), radius / 2))
self.camLens.set_far(max(self.camLens.get_default_far(), distance + radius * 2))
trackball = self.trackball.node()
trackball.set_origin(center)
trackball.set_pos(0, distance, 0)
trackball.setForwardScale(distance * 0.006)
# Create a light if the model does not have one
if not self.model_root.find('**/+Light'):
self.light = self.render.attach_new_node(p3d.PointLight('light'))
self.light.set_pos(0, -distance, distance)
self.render.set_light(self.light)
# Move lights to render
self.model_root.clear_light()
for light in self.model_root.find_all_matches('**/+Light'):
light.parent.wrt_reparent_to(self.render)
self.render.set_light(light)
# Add some ambient light
self.ambient = self.render.attach_new_node(p3d.AmbientLight('ambient'))
self.ambient.node().set_color((.2, .2, .2, 1))
self.render.set_light(self.ambient)
if self.model_root.find('**/+Character'):
self.anims = p3d.AnimControlCollection()
p3d.autoBind(self.model_root.node(), self.anims, ~0)
if self.anims.get_num_anims() > 0:
self.anims.get_anim(0).loop(True)
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')
def __init__(
self, **kwargs
): # optional arguments: title, fullscreen, size, position, vsync, borderless, show_ursina_splash, render_mode, development_mode, editor_ui_enabled.
for name in ('size', 'vsync'):
if name in kwargs and hasattr(window, name):
setattr(window, name, kwargs[name])
if 'development_mode' in kwargs:
application.development_mode = kwargs['development_mode']
super().__init__()
application.base = base
gltf.patch_loader(self.loader)
window.late_init()
for name in ('title', 'fullscreen', 'position', 'show_ursina_splash',
'borderless', 'render_mode'):
if name in kwargs and hasattr(window, name):
setattr(window, name, kwargs[name])
# camera
camera._cam = base.camera
camera._cam.reparent_to(camera)
camera.render = base.render
camera.position = (0, 0, -20)
scene.camera = camera
camera.set_up()
# input
base.buttonThrowers[0].node().setButtonDownEvent('buttonDown')
base.buttonThrowers[0].node().setButtonUpEvent('buttonUp')
base.buttonThrowers[0].node().setButtonRepeatEvent('buttonHold')
self._input_name_changes = {
'mouse1': 'left mouse down',
'mouse1 up': 'left mouse up',
'mouse2': 'middle mouse down',
'mouse2 up': 'middle mouse up',
'mouse3': 'right mouse down',
'mouse3 up': 'right mouse up',
'wheel_up': 'scroll up',
'wheel_down': 'scroll down',
'arrow_left': 'left arrow',
'arrow_left up': 'left arrow up',
'arrow_up': 'up arrow',
'arrow_up up': 'up arrow up',
'arrow_down': 'down arrow',
'arrow_down up': 'down arrow up',
'arrow_right': 'right arrow',
'arrow_right up': 'right arrow up',
'lcontrol': 'left control',
'rcontrol': 'right control',
'lshift': 'left shift',
'rshift': 'right shift',
'lalt': 'left alt',
'ralt': 'right alt',
'lcontrol up': 'left control up',
'rcontrol up': 'right control up',
'lshift up': 'left shift up',
'rshift up': 'right shift up',
'lalt up': 'left alt up',
'ralt up': 'right alt up',
'control-mouse1': 'left mouse down',
'control-mouse2': 'middle mouse down',
'control-mouse3': 'right mouse down',
'shift-mouse1': 'left mouse down',
'shift-mouse2': 'middle mouse down',
'shift-mouse3': 'right mouse down',
'alt-mouse1': 'left mouse down',
'alt-mouse2': 'middle mouse down',
'alt-mouse3': 'right mouse down',
'page_down': 'page down',
'page_down up': 'page down up',
'page_up': 'page up',
'page_up up': 'page up up',
}
self.accept('buttonDown', self.input)
self.accept('buttonUp', self.input_up)
self.accept('buttonHold', self.input_hold)
base.disableMouse()
mouse._mouse_watcher = base.mouseWatcherNode
mouse.enabled = True
self.mouse = mouse
from ursina import gamepad
scene.set_up()
self._update_task = taskMgr.add(self._update, "update")
# try to load settings that need to be applied before entity creation
application.load_settings()
from ursina import HotReloader
# make sure it's running from a file and not an interactive session.
application.hot_reloader = HotReloader(
__main__.__file__ if hasattr(__main__, '__file__') else 'None')
window.make_editor_gui()
if 'editor_ui_enabled' in kwargs:
window.editor_ui.enabled = kwargs['editor_ui_enabled']
def __init__(self):
load_prc_file_data(
"", """
win-size 1920 1080
show-frame-rate-meter #t
view-frustum-cull 0
textures-power-2 none
gl-depth-zero-to-one true
hardware-animated-vertices true
basic-shaders-only false
loader-num-threads 24
frame-rate-meter-milliseconds true
window-title PBR Hardware Skinning Demo
fullscreen #f
""")
# Initialize the showbase
super().__init__()
pipeline = simplepbr.init()
pipeline.enable_shadows = False
pipeline.max_lights = 10
gltf.patch_loader(self.loader)
self.accept("escape", sys.exit, [0])
self.cam.setPos(-10, 10, 3)
self.cam.lookAt(0, 0, 0)
amb_light = AmbientLight('amblight')
amb_light.setColor((0.2, 0.2, 0.2, 1))
amb_light_node = self.render.attachNewNode(amb_light)
self.render.setLight(amb_light_node)
p_light = Spotlight('p_light')
p_light.setColor((1, 1, 1, 1))
p_light.setShadowCaster(True, 1024, 1024)
lens = PerspectiveLens()
p_light.setLens(lens)
p_light_node = self.render.attachNewNode(p_light)
p_light_node.setPos(-5, -5, 5)
p_light_node.lookAt(0, 0, 0)
self.render.setLight(p_light_node)
#############################################
# reparent player character to render node
char_body = actor_ai.tilter
char_body.reparent_to(self.render)
char_body.setScale(1)
# prototype hardware skinning shader for Actor nodes
actor_shader = Shader.load(Shader.SL_GLSL,
"shaders/simplepbr_vert_mod_1.vert",
"shaders/simplepbr_frag_mod_1.frag")
actor_shader = ShaderAttrib.make(actor_shader)
actor_shader = actor_shader.setFlag(ShaderAttrib.F_hardware_skinning,
True)
# char_body.setShaderAuto()
char_body.setAttrib(actor_shader)
# animate the Actor
tilt_ctrl = actor_ai.tilter.getAnimControl('wave')
if not tilt_ctrl.isPlaying():
actor_ai.tilter.loop('wave')
actor_ai.tilter.setPlayRate(3.0, 'wave')
def move(Task):
# print('the scene is updating')
return Task.cont
self.task_mgr.add(move)
def __init__(self):
load_prc_file_data(
"", """
win-size 1680 1050
window-title P3D Space Tech Demo Skybox Test 1
show-frame-rate-meter #t
framebuffer-multisample 1
multisamples 4
view-frustum-cull 0
textures-power-2 none
hardware-animated-vertices #t
gl-depth-zero-to-one true
clock-frame-rate 60
interpolate-frames 1
cursor-hidden #t
fullscreen #f
""")
# Initialize the showbase
super().__init__()
gltf.patch_loader(self.loader)
props = WindowProperties()
props.set_mouse_mode(WindowProperties.M_relative)
base.win.request_properties(props)
base.set_background_color(0.5, 0.5, 0.8)
self.camLens.set_fov(80)
self.camLens.set_near_far(0.01, 90000)
self.camLens.set_focal_length(7)
self.camera.set_pos(-300, -300, 0)
# ConfigVariableManager.getGlobalPtr().listVariables()
# point light generator
for x in range(0, 3):
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = self.render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20),
random.uniform(20, 21))
self.render.set_light(plight_1_node)
# point light for volumetric lighting filter
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = self.render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20), random.uniform(20, 21))
self.render.set_light(plight_1_node)
scene_filters = CommonFilters(base.win, base.cam)
scene_filters.set_bloom()
scene_filters.set_high_dynamic_range()
scene_filters.set_exposure_adjust(0.6)
scene_filters.set_gamma_adjust(1.1)
# scene_filters.set_volumetric_lighting(plight_1_node, 32, 0.5, 0.7, 0.1)
# scene_filters.set_blur_sharpen(0.9)
# scene_filters.set_ambient_occlusion(32, 0.05, 2.0, 0.01, 0.000002)
self.accept("f3", self.toggle_wireframe)
self.accept("escape", sys.exit, [0])
exponential_fog = Fog('world_fog')
exponential_fog.set_color(0.6, 0.7, 0.7)
# this is a very low fog value, set it higher for a greater effect
exponential_fog.set_exp_density(0.00009)
# self.render.set_fog(exponential_fog)
self.game_start = 0
skybox = self.loader.load_model('skyboxes/40k_test.gltf')
skybox.reparent_to(self.camera)
skybox.setCompass()
skybox.setBin("background", 1)
skybox.setDepthWrite(False)
aster_bool = False
# add some asteroids
for x in range(100):
ran_pos = Vec3(random.uniform(-300,
300), random.uniform(-300, 300),
random.uniform(-300, 300))
if not aster_bool:
asteroid = self.loader.load_model('models/asteroid_1.gltf')
aster_bool = True
if aster_bool:
asteroid = self.loader.load_model('models/asteroid_2.gltf')
aster_bool = False
asteroid.reparent_to(self.render)
asteroid.set_pos(ran_pos)
asteroid.set_scale(random.uniform(0.1, 10))
a_pos = asteroid.get_pos()
ran_inter = random.uniform(-20, 20)
ran_h = random.uniform(-180, 180)
asteroid.set_h(ran_h)
a_rotate = LerpPosHprInterval(asteroid, 100,
(a_pos[0] + ran_inter, a_pos[1] +
ran_inter, a_pos[2] + ran_inter),
(360, 360, 0)).loop()
# load the scene shader
scene_shader = Shader.load(Shader.SL_GLSL,
"shaders/simplepbr_vert_mod_1.vert",
"shaders/simplepbr_frag_mod_1.frag")
self.render.set_shader(scene_shader)
self.render.set_antialias(AntialiasAttrib.MMultisample)
scene_shader = ShaderAttrib.make(scene_shader)
scene_shader = scene_shader.setFlag(ShaderAttrib.F_hardware_skinning,
True)
# directly make a text node to display text
text_2 = TextNode('text_2_node')
text_2.set_text("P3D Space Tech Demo Skybox Test")
text_2_node = self.aspect2d.attach_new_node(text_2)
text_2_node.set_scale(0.04)
text_2_node.set_pos(-1.4, 0, 0.8)
# import font and set pixels per unit font quality
nunito_font = self.loader.load_font('fonts/Nunito/Nunito-Light.ttf')
nunito_font.set_pixels_per_unit(100)
nunito_font.set_page_size(512, 512)
# apply font
text_2.set_font(nunito_font)
text_2.set_text_color(0.1, 0.1, 0.1, 1)
# 3D player movement system begins
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"run": 0,
"jump": 0,
"up": 0,
"down": 0
}
def setKey(key, value):
self.keyMap[key] = value
# define button map
self.accept("a", setKey, ["left", 1])
self.accept("a-up", setKey, ["left", 0])
self.accept("d", setKey, ["right", 1])
self.accept("d-up", setKey, ["right", 0])
self.accept("w", setKey, ["forward", 1])
self.accept("w-up", setKey, ["forward", 0])
self.accept("s", setKey, ["backward", 1])
self.accept("s-up", setKey, ["backward", 0])
self.accept("lshift", setKey, ["up", 1])
self.accept("lshift-up", setKey, ["up", 0])
self.accept("lcontrol", setKey, ["down", 1])
self.accept("lcontrol-up", setKey, ["down", 0])
self.accept("space", setKey, ["jump", 1])
self.accept("space-up", setKey, ["jump", 0])
# disable mouse
self.disable_mouse()
# the player movement speed
self.inc_var = 1
self.max_speed_inc = 0.02
self.max_abs_speed = 0.2
self.inertia_x = 0
self.inertia_y = 0
self.inertia_z = 0
def move(Task):
if self.game_start > 0:
# get mouse data
mouse_watch = base.mouseWatcherNode
if mouse_watch.has_mouse():
pointer = base.win.get_pointer(0)
mouseX = pointer.get_x()
mouseY = pointer.get_y()
# screen sizes
window_Xcoord_halved = base.win.get_x_size() // 2
window_Ycoord_halved = base.win.get_y_size() // 2
# mouse speed
mouseSpeedX = 0.2
mouseSpeedY = 0.2
# maximum and minimum pitch
maxPitch = 90
minPitch = -50
# cam view target initialization
camViewTarget = LVecBase3f()
# clock
dt = globalClock.get_dt()
if base.win.movePointer(0, window_Xcoord_halved,
window_Ycoord_halved):
p = 0
if mouse_watch.has_mouse():
# calculate the pitch of camera
p = self.camera.get_p() - (
mouseY - window_Ycoord_halved) * mouseSpeedY
# sanity checking
if p < minPitch:
p = minPitch
elif p > maxPitch:
p = maxPitch
if mouse_watch.has_mouse():
# directly set the camera pitch
self.camera.set_p(p)
camViewTarget.set_y(p)
# rotate the self.player's heading according to the mouse x-axis movement
if mouse_watch.has_mouse():
h = self.camera.get_h() - (
mouseX - window_Xcoord_halved) * mouseSpeedX
if mouse_watch.has_mouse():
# sanity checking
if h < -360:
h += 360
elif h > 360:
h -= 360
self.camera.set_h(h)
camViewTarget.set_x(h)
if self.inertia_x > self.max_abs_speed:
self.inertia_x = self.max_abs_speed
if self.inertia_y > self.max_abs_speed:
self.inertia_y = self.max_abs_speed
if self.inertia_z > self.max_abs_speed:
self.inertia_z = self.max_abs_speed
if self.keyMap["right"]:
if self.inertia_x > 0:
self.inertia_x += self.inc_var * dt
else:
self.inertia_x = self.max_speed_inc
self.camera.set_x(self.camera, self.inertia_x)
if self.keyMap["left"]:
if self.inertia_x < 0:
self.inertia_x -= self.inc_var * dt
else:
self.inertia_x = -self.max_speed_inc
self.camera.set_x(self.camera, self.inertia_x)
if self.keyMap["forward"]:
# print(self.inertia_y)
if self.inertia_y > 0:
self.inertia_y += self.inc_var * dt
else:
self.inertia_y = self.max_speed_inc
self.camera.set_y(self.camera, self.inertia_y)
if self.keyMap["backward"]:
if self.inertia_y < 0:
self.inertia_y -= self.inc_var * dt
else:
self.inertia_y = -self.max_speed_inc
self.camera.set_y(self.camera, self.inertia_y)
if self.keyMap["up"]:
if self.inertia_z > 0:
self.inertia_z += self.inc_var * dt
else:
self.inertia_z = self.max_speed_inc
self.camera.set_z(self.camera, self.inertia_z)
if self.keyMap["down"]:
if self.inertia_z < 0:
self.inertia_z -= self.inc_var * dt
else:
self.inertia_z = -self.max_speed_inc
self.camera.set_z(self.camera, self.inertia_z)
else:
self.camera.set_x(self.camera, self.inertia_x)
self.camera.set_y(self.camera, self.inertia_y)
self.camera.set_z(self.camera, self.inertia_z)
return Task.cont
def update(Task):
if self.game_start < 1:
self.game_start = 1
return Task.cont
self.task_mgr.add(move)
self.task_mgr.add(update)
def __init__(
self,
agent_interfaces,
traffic_sim,
envision: EnvisionClient = None,
visdom: VisdomClient = None,
timestep_sec=0.1,
reset_agents_only=False,
zoo_workers=None,
auth_key=None,
):
'''
try:
super().__init__(self, windowType="offscreen")
except Exception as e:
# Known reasons for this failing:
raise Exception(
"Display is not found. Try running with different configurations of "
"`export Display=` using `:0`, `:1`... If this does not work please consult "
"the documentation."
) from e
'''
self.loader = Loader(self)
gltf.patch_loader(self.loader)
self._log = logging.getLogger(self.__class__.__name__)
self.__configAspectRatio = ConfigVariableDouble('aspect-ratio',
0).getValue()
self._is_setup = False
self._scenario: Scenario = None
self._envision: EnvisionClient = envision
self._visdom: VisdomClient = visdom
self._timestep_sec = timestep_sec
self._traffic_sim = traffic_sim
self._motion_planner_provider = MotionPlannerProvider()
self._traffic_history_provider = TrafficHistoryProvider()
self._providers = [
self._traffic_sim,
self._motion_planner_provider,
self._traffic_history_provider,
]
# We buffer provider state between steps to compensate for TRACI's timestep delay
self._last_provider_state = None
self._reset_agents_only = reset_agents_only # a.k.a "teleportation"
self._imitation_learning_mode = False
self.finalExitCallbacks = []
# Global clock always proceeds by a fixed dt on each tick
from direct.task.TaskManagerGlobal import taskMgr
self.taskMgr = taskMgr
self.task_mgr = taskMgr
self.taskMgr.clock.setMode(ClockObject.M_non_real_time)
self.taskMgr.clock.setDt(timestep_sec)
self._elapsed_sim_time = 0
self.engine = GraphicsEngine.get_global_ptr()
self.graphicsEngine = self.engine
fb_prop = FrameBufferProperties()
fb_prop.rgb_color = 1
fb_prop.color_bits = 3 * 8
fb_prop.back_buffers = 1
self.pipe = GraphicsPipeSelection.get_global_ptr().make_default_pipe()
flags = GraphicsPipe.BFFbPropsOptional
flags = flags | GraphicsPipe.BFRefuseWindow
self.win = self.engine.make_output(
self.pipe,
name="window",
sort=0,
fb_prop=fb_prop,
win_prop=WindowProperties(size=(800, 600)),
flags=flags)
#self.setBackgroundColor(0, 0, 0, 1)
#self.win.set_clear_color_active(True)
#self.win.set_clear_clolor((0.5,0.5,0.5,1))
self.frameRateMeter = None
# Displayed framerate is misleading since we are not using a realtime clock
self.setFrameRateMeter(False)
self.render = NodePath("render")
#self.cam = self.render.attach_new_node(Camera("camera"))
#self.cam.node().set_lens(PerspectiveLens())
self.camera = None
self.camList = []
self.mouse2cam = NodePath(Transform2SG('mouse2cam'))
self.render.setAttrib(RescaleNormalAttrib.makeDefault())
self.render.setTwoSided(0)
self.backfaceCullingEnabled = 1
self.textureEnabled = 1
self.wireframeEnabled = 0
# For macOS GUI. See our `BulletClient` docstring for details.
# from .utils.bullet import BulletClient
# self._bullet_client = BulletClient(pybullet.GUI)
self._bullet_client = bc.BulletClient(pybullet.DIRECT)
self._pybullet_action_spaces = {
ActionSpaceType.Continuous,
ActionSpaceType.Lane,
ActionSpaceType.ActuatorDynamic,
ActionSpaceType.LaneWithContinuousSpeed,
ActionSpaceType.Trajectory,
ActionSpaceType.MPC,
}
# Set up indices
self._agent_manager = AgentManager(agent_interfaces, zoo_workers,
auth_key)
self._vehicle_index = VehicleIndex()
# TODO: Should not be stored in SMARTS
self._vehicle_collisions = defaultdict(
list) # list of `Collision` instances
self._vehicle_states = []
self._bubble_manager = None
self._trap_manager: TrapManager = None
# SceneGraph-related setup
self._root_np = None
self._vehicles_np = None
self._road_network_np = None
self._ground_bullet_id = None
def __init__(self):
ShowBase.__init__(self)
gltf.patch_loader(self.loader)
properties = WindowProperties()
properties.setSize(1000, 750)
self.disableMouse()
self.environment = loader.loadModel("environment/island.gltf")
self.environment.reparentTo(render)
self.environment.setPos(0,0,-3)
self.environment.setHpr(0,-90,0)
""" I put this becase I think there is a default light that I cant reach and manupulate.
thets why I setLightsOff first. Otherwise Ican't create or cast shadows etc. """
self.environment.setLightOff()
mats = self.environment .findAllMaterials()
mats[0].clearBaseColor()
mats[1].clearBaseColor()
mats[0].setShininess(200)
mats[1].setShininess(100)
""" In this block I create a textureBuffer and create camera
on that buffer that its display region is upper right corner of the window
I use that region to create saveScreenShot xxxx or create a numpy array out of it
(numpy_image_data)
second try is to make a screenshot directly from the buffer which is not so important
Both works though """
self.useTrackball()
# ambientLight = AmbientLight("ambient light")
# ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
# self.ambientLightNodePath = render.attachNewNode(ambientLight)
# render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
mainLight.setShadowCaster(True,1000,1000)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
""" I put it here again"""
self.environment.setLight(self.mainLightNodePath)
pointLight = PointLight("point light")
pointLight.setShadowCaster(True,1000,1000)
self.pointLightNodePath = render.attachNewNode(pointLight)
self.pointLightNodePath.setPos(0,0,10)
render.setLight(self.pointLightNodePath)
""" and again """
self.environment.setLight(self.pointLightNodePath)
render.setShaderAuto()
self.tempActor2 = Actor("models/cube.bam")
self.tempActor2.reparentTo(render)
self.tempActor2.setPos(-2, 2, -1)
self.tempActor2.setScale(.2)
self.monkey = Actor("models/monkey")
self.monkey.set_scale(.25)
self.monkey.reparentTo(render)
self.monkey.set_pos(-7,-7,2)
self.monkey.lookAt(self.tempActor2)
self.monkey2 = Actor("models/monkey")
self.monkey2.set_scale(.25)
self.monkey2.reparentTo(render)
self.monkey2.set_pos(0,3,1)
self.monkey2.lookAt(self.tempActor2)
tex=Texture()
self.mybuffer = self.win.makeTextureBuffer("My Buffer", 512, 512,tex,to_ram=True)
self.mybuffer.setSort(-100)
mycamera = self.makeCamera(self.mybuffer,displayRegion=(.5,1,.5,1))
mycamera.reparentTo(self.monkey)
tex2=Texture()
mybuffer2 = self.win.makeTextureBuffer("My Buffer2", 512, 512,tex,to_ram=True)
mybuffer2.setSort(-500)
mycamera2 = self.makeCamera(mybuffer2,displayRegion=(0,.5,0,.5))
mycamera2.reparentTo(self.monkey2)
self.graphicsEngine.renderFrame()
print(self.mybuffer.getActiveDisplayRegions())
"""shadows for cameras missing here in screenshot"""
save_it=self.mybuffer.getActiveDisplayRegion(0).saveScreenshotDefault('1111')
my_output=self.mybuffer.getActiveDisplayRegion(0).getScreenshot()
numpy_image_data=np.array(my_output.getRamImageAs("RGB"), np.float32)
"""shadows for cameras missing here in screenshot"""
save_it2=mybuffer2.getActiveDisplayRegion(0).saveScreenshotDefault('2222')
my_output2=mybuffer2.getActiveDisplayRegion(0).getScreenshot()
numpy_image_data2=np.array(my_output2.getRamImageAs("RGB"), np.float32)
print(numpy_image_data)
file_name=Filename.fromOsSpecific("save_gameDat_001.png")
self.mybuffer.saveScreenshot(file_name)
print('Cameras')
print(self.camList)
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
print('Active Display Regions')
print(self.win.getActiveDisplayRegions())
print(self.win.getDisplayRegions())
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.updateTask = taskMgr.add(self.update, "update")
def showbase():
p3d.load_prc_file_data('', 'window-type none')
base = ShowBase()
gltf.patch_loader(base.loader)
return base
