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