class MainApp(ShowBase): def __init__(self): # Setup window size, title and so on load_prc_file_data("", """ win-size 1600 900 window-title Render Pipeline - Car Demo """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ self.render_pipeline.daytime_mgr.time = "20:08" # Load the scene model = loader.loadModel("scene/scene.bam") # model = loader.loadModel("scene2/Scene.bam") model.reparent_to(render) self.render_pipeline.prepare_scene(model) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position( Vec3(-7.5, -5.3, 1.8), Vec3(-5.9, -4.0, 1.6)) self.controller.setup() base.accept("l", self.tour) def tour(self): """ Camera flythrough """ mopath = ( (Vec3(-10.8645000458, 9.76458263397, 2.13306283951), Vec3(-133.556228638, -4.23447799683, 0.0)), (Vec3(-10.6538448334, -5.98406457901, 1.68028640747), Vec3(-59.3999938965, -3.32706642151, 0.0)), (Vec3(9.58458328247, -5.63625621796, 2.63269257545), Vec3(58.7906494141, -9.40668964386, 0.0)), (Vec3(6.8135137558, 11.0153560638, 2.25509500504), Vec3(148.762527466, -6.41223621368, 0.0)), (Vec3(-9.07093334198, 3.65908527374, 1.42396306992), Vec3(245.362503052, -3.59927511215, 0.0)), (Vec3(-8.75390911102, -3.82727789879, 0.990055501461), Vec3(296.090484619, -0.604830980301, 0.0)), ) self.controller.play_motion_path(mopath, 3.0)
class MainApp(ShowBase): """ Main Testing Showbase """ def __init__(self): # Setup window size, title and so on load_prc_file_data( "", """ win-size 1600 900 window-title Render Pipeline - Lights demo """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ # Set time of day self.render_pipeline.daytime_mgr.time = "4:50" self.half_energy = 5000 self.lamp_fov = 70 self.lamp_radius = 10 # Load the scene model = loader.loadModel("scene/Scene.bam") model.reparent_to(render) # Animate balls, this is for testing the motion blur blend_type = "noBlend" np = model.find("**/MBRotate") np.hprInterval(1.5, Vec3(360, 360, 0), Vec3(0, 0, 0), blendType=blend_type).loop() np = model.find("**/MBUpDown") np_pos = np.get_pos() - Vec3(0, 0, 2) Sequence( np.posInterval(0.15, np_pos + Vec3(0, 0, 6), np_pos, blendType=blend_type), np.posInterval(0.15, np_pos, np_pos + Vec3(0, 0, 6), blendType=blend_type)).loop() np = model.find("**/MBFrontBack") np_pos = np.get_pos() - Vec3(0, 0, 2) Sequence( np.posInterval(0.15, np_pos + Vec3(0, 6, 0), np_pos, blendType=blend_type), np.posInterval(0.15, np_pos, np_pos + Vec3(0, 6, 0), blendType=blend_type)).loop() np = model.find("**/MBScale") Sequence( np.scaleInterval(0.2, Vec3(1.5), Vec3(1), blendType=blend_type), np.scaleInterval(0.2, Vec3(1), Vec3(1.5), blendType=blend_type)).loop() # Generate temperature lamps # This shows how to procedurally create lamps. In this case, we # base the lights positions on empties created in blender. self._lights = [] light_key = lambda light: int(light.get_name().split("LampLum")[-1]) lumlamps = sorted(model.find_all_matches("**/LampLum*"), key=light_key) for lumlamp in lumlamps: lum = float(lumlamp.get_name()[len("LampLum"):]) light = SpotLight() light.direction = (0, -1.5, -1) light.fov = self.lamp_fov light.set_color_from_temperature(lum * 1000.0) light.energy = self.half_energy light.pos = lumlamp.get_pos(self.render) light.radius = self.lamp_radius light.casts_shadows = False light.shadow_map_resolution = 256 self.render_pipeline.add_light(light) # Put Pandas on the edges if lumlamp in lumlamps[0:2] + lumlamps[-2:]: panda = loader.loadModel("panda") panda.reparent_to(render) panda_mat = Material("default") panda_mat.emission = 0 panda.set_material(panda_mat) panda.set_pos(light.pos) panda.set_z(0.65) panda.set_h(180 + randint(-60, 60)) panda.set_scale(0.2) panda.set_y(panda.get_y() - 3.0) self._lights.append(light) self.render_pipeline.prepare_scene(model) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(23.9, 42.5, 13.4), Vec3(23.8, 33.4, 10.8)) self.controller.setup() self.day_time = 0.3 self.time_direction = 0 # Keys to modify the time, disabled in the demo self.accept("k", self.reset) self.accept("p", self.set_time_direction, [ 1, ]) self.accept("p-up", self.set_time_direction, [ 0, ]) self.accept("i", self.set_time_direction, [ -1, ]) self.accept("i-up", self.set_time_direction, [ 0, ]) self.addTask(self.update, "update") def reset(self): self.day_time = 0.209 def set_time_direction(self, direction): self.time_direction = direction def update(self, task): """ Update method """ frame_time = globalClock.get_frame_time() # Make the lights glow for i, light in enumerate(self._lights): brightness = math.sin(0.4 * i + frame_time * 1.0) light.energy = max( 0, self.half_energy / 2 + brightness * self.half_energy) return task.cont
class MainApp(ShowBase): """ Main Testing Showbase """ def __init__(self): # Setup window size, title and so on load_prc_file_data("", """ win-size 1600 900 window-title Render Pipeline - Benchmark """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, PointLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ # Set time of day self.render_pipeline.daytime_mgr.time = "17:41" self.camLens.set_fov(90) model = self.loader.load_model("scene/Scene.bam") model.reparent_to(self.render) model.flatten_strong() num_rows = 255 img = PNMImage("scene/lights.png") for x in range(num_rows): for y in range(num_rows): light = PointLight() # light.direction = (0, 0, -1) # light.fov = 60 # light.set_color_from_temperature(randint(2000, 20000)) light.color = img.get_xel(x * 1, y * 1) light.energy = 5000 * (x / num_rows) light.pos = Vec3(-(x - num_rows // 2) / num_rows * 1000.0, (y - num_rows // 2) / num_rows * 1000.0, 2) light.radius = 4 light.inner_radius = 0.5 light.casts_shadows = False light.shadow_map_resolution = 256 self.render_pipeline.add_light(light) self.render_pipeline.prepare_scene(model) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(0, 450, 200), Vec3(0)) self.controller.setup() self.accept("l", self.benchmark) def benchmark(self): mopath = ( (Vec3(0.0, 450.0, 200.0), Vec3(180.0, -23.9624938965, 0.0)), (Vec3(-190.848297119, 304.510772705, 90.5852050781), Vec3(209.767547607, -19.2802791595, 0.0)), (Vec3(-220.74269104, 10.6886262894, 38.7188148499), Vec3(278.595062256, -16.6669464111, -0.00123210949823)), (Vec3(-51.2080802917, -188.072463989, 50.2380104065), Vec3(364.747375488, -22.7647132874, 0.0)), (Vec3(211.633651733, -190.621276855, 216.169631958), Vec3(413.887451172, -40.1869468689, -0.000118153897347)), (Vec3(320.780090332, 303.404388428, 341.834014893), Vec3(495.000030518, -41.1669464111, 0.00174981483724)), (Vec3(125.150436401, 294.57989502, 218.834960938), Vec3(444.363800049, 3.80416536331, 0.0)), (Vec3(-355.501434326, 153.010559082, 68.0701370239), Vec3(611.234924316, -11.5491724014, 0.000359044410288)), (Vec3(-118.283355713, -115.640907288, 6.09887886047), Vec3(637.222473145, -8.82695007324, 0.0)), (Vec3(80.3096160889, 12.4637413025, 26.0630741119), Vec3(676.439758301, -24.3980617523, 0.0)), (Vec3(69.6195449829, 152.581176758, 14.8633785248), Vec3(881.898925781, -15.3602952957, 0.0)), (Vec3(-202.29776001, 109.818962097, 94.7222290039), Vec3(962.381530762, -27.7736206055, 0.00155594921671)), (Vec3(6.89826059341, -412.195037842, 221.591659546), Vec3(1080.42749023, -31.1491756439, 0.0)), (Vec3(362.657867432, -34.1290054321, 216.362884521), Vec3(1166.81677246, -35.0691833496, 0.0)), (Vec3(-0.339450836182, 452.040649414, 199.996627808), Vec3(180.0, -23.9624938965, 0.0)), ) self.controller.play_motion_path(mopath, 3.0)
class MainApp(ShowBase): """ Main Testing Showbase """ def __init__(self): # Setup window size, title and so on load_prc_file_data("", """ win-size 1600 900 window-title Render Pipeline - Lights demo """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ # Set time of day self.render_pipeline.daytime_mgr.time = "4:50" self.half_energy = 5000 self.lamp_fov = 70 self.lamp_radius = 10 # Load the scene model = loader.loadModel("scene/Scene.bam") model.reparent_to(render) # Animate balls, this is for testing the motion blur blend_type = "noBlend" np = model.find("**/MBRotate") np.hprInterval(1.5, Vec3(360, 360, 0), Vec3(0, 0, 0), blendType=blend_type).loop() np = model.find("**/MBUpDown") np_pos = np.get_pos() - Vec3(0, 0, 2) Sequence( np.posInterval(0.15, np_pos + Vec3(0, 0, 6), np_pos, blendType=blend_type), np.posInterval(0.15, np_pos, np_pos + Vec3(0, 0, 6), blendType=blend_type)).loop() np = model.find("**/MBFrontBack") np_pos = np.get_pos() - Vec3(0, 0, 2) Sequence( np.posInterval(0.15, np_pos + Vec3(0, 6, 0), np_pos, blendType=blend_type), np.posInterval(0.15, np_pos, np_pos + Vec3(0, 6, 0), blendType=blend_type)).loop() np = model.find("**/MBScale") Sequence( np.scaleInterval(0.2, Vec3(1.5), Vec3(1), blendType=blend_type), np.scaleInterval(0.2, Vec3(1), Vec3(1.5), blendType=blend_type)).loop() # Generate temperature lamps # This shows how to procedurally create lamps. In this case, we # base the lights positions on empties created in blender. self._lights = [] light_key = lambda light: int(light.get_name().split("LampLum")[-1]) lumlamps = sorted(model.find_all_matches("**/LampLum*"), key=light_key) for lumlamp in lumlamps: lum = float(lumlamp.get_name()[len("LampLum"):]) light = SpotLight() light.direction = (0, -1.5, -1) light.fov = self.lamp_fov light.set_color_from_temperature(lum * 1000.0) light.energy = self.half_energy light.pos = lumlamp.get_pos(self.render) light.radius = self.lamp_radius light.casts_shadows = False light.shadow_map_resolution = 256 self.render_pipeline.add_light(light) # Put Pandas on the edges if lumlamp in lumlamps[0:2] + lumlamps[-2:]: panda = loader.loadModel("panda") panda.reparent_to(render) panda_mat = Material("default") panda_mat.emission = 0 panda.set_material(panda_mat) panda.set_pos(light.pos) panda.set_z(0.65) panda.set_h(180 + randint(-60, 60)) panda.set_scale(0.2) panda.set_y(panda.get_y() - 3.0) self._lights.append(light) self.render_pipeline.prepare_scene(model) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(23.9, 42.5, 13.4), Vec3(23.8, 33.4, 10.8)) self.controller.setup() self.day_time = 0.3 self.time_direction = 0 # Keys to modify the time, disabled in the demo self.accept("k", self.reset) self.accept("p", self.set_time_direction, [1,]) self.accept("p-up", self.set_time_direction, [0,]) self.accept("i", self.set_time_direction, [-1,]) self.accept("i-up", self.set_time_direction, [0,]) self.addTask(self.update, "update") def reset(self): self.day_time = 0.209 def set_time_direction(self, direction): self.time_direction = direction def update(self, task): """ Update method """ frame_time = globalClock.get_frame_time() # Make the lights glow for i, light in enumerate(self._lights): brightness = math.sin(0.4 * i + frame_time * 1.0) light.energy = max(0, self.half_energy / 2 + brightness * self.half_energy) return task.cont
class MainApp(ShowBase): def __init__(self): # Setup window size, title and so on load_prc_file_data("", """ win-size 1600 900 window-title Render Pipeline - Shading Models Demo """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ # Set time of day self.render_pipeline.daytime_mgr.time = 0.769 # Load the scene model = loader.loadModel("scene/TestScene.bam") model.reparent_to(render) self.render_pipeline.prepare_scene(model) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position( Vec3(6.6, -18.8, 4.5), Vec3(4.7, -16.7, 3.4)) self.controller.setup() base.accept("l", self.tour) base.accept("r", self.reload_shaders) def reload_shaders(self): self.render_pipeline.reload_shaders() self.render_pipeline.prepare_scene(render) def tour(self): mopath = ( (Vec3(3.97601628304, -15.5422525406, 1.73230814934), Vec3(49.2462043762, -11.7619161606, 0.0)), (Vec3(4.37102460861, -6.52981519699, 2.84148645401), Vec3(138.54864502, -15.7908058167, 0.0)), (Vec3(-5.88968038559, -13.9816446304, 2.44033527374), Vec3(302.348571777, -13.2863616943, 0.0)), (Vec3(5.23844909668, -18.1897411346, 4.54698801041), Vec3(402.91229248, -14.7019147873, 0.0)), (Vec3(-7.27328443527, -0.466051012278, 3.30696845055), Vec3(607.032165527, -19.6019115448, 0.0)), (Vec3(5.33415555954, 1.92750489712, 2.53945565224), Vec3(484.103546143, -11.9796953201, 0.0)), (Vec3(-0.283608138561, -6.86583900452, 1.43702816963), Vec3(354.63848877, -4.79302883148, 0.0)), (Vec3(-11.7576808929, 7.0855755806, 3.40899515152), Vec3(272.73840332, -12.959692955, 0.0)), (Vec3(7.75462722778, 13.220041275, 3.97876667976), Vec3(126.342140198, -19.4930171967, 0.0)), (Vec3(-2.10827493668, 4.78230571747, 1.27567899227), Vec3(-40.1353683472, -5.77301359177, 0.0)), (Vec3(8.67115211487, 16.9084873199, 3.72598099709), Vec3(89.5658569336, -10.9996757507, 0.0)), (Vec3(-8.1254825592, 26.6411190033, 3.21335697174), Vec3(268.092102051, -12.1974525452, 0.0)), (Vec3(7.89382314682, 45.8911399841, 4.47727441788), Vec3(498.199554443, -11.3263425827, 0.0)), (Vec3(-2.33054184914, 43.8977775574, 1.86498868465), Vec3(551.198242188, 13.6092195511, 0.0)), (Vec3(4.80335664749, 36.9664497375, 6.16300296783), Vec3(810.128417969, -10.6730031967, 0.0)), (Vec3(45.0654678345, 7.54712438583, 22.2645874023), Vec3(808.238586426, -17.5330123901, 0.0)), (Vec3(5.99377584457, -12.3760728836, 4.53536558151), Vec3(806.978820801, -2.39745855331, 0.0)), (Vec3(6.05853939056, -1.72227275372, 4.53848743439), Vec3(809.65637207, -2.39745855331, 0.0)), (Vec3(4.81568479538, 8.28769683838, 4.48393821716), Vec3(809.65637207, -2.39745855331, 0.0)), (Vec3(5.82831144333, 17.5230751038, 4.52401590347), Vec3(809.65637207, -2.39745855331, 0.0)), (Vec3(4.09594917297, 26.7909412384, 4.44915866852), Vec3(809.65637207, -2.39745855331, 0.0)), (Vec3(4.39108037949, 37.2143096924, 5.16932630539), Vec3(809.65637207, -2.39745855331, 0.0)), ) self.controller.play_motion_path(mopath, 2.3)
class Application(ShowBase): """ Main Testing Showbase """ def __init__(self): # Setup window size, title and so on load_prc_file_data( "", """ win-size 1600 900 window-title Render Pipeline - Material blending example """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ # Set time of day self.render_pipeline.daytime_mgr.time = "6:43" # Load the scene model = loader.loadModel("scene/Scene.bam") model.reparent_to(render) # Set the material blending effect on the terrain terrain = model.find("**/Terrain") self.render_pipeline.set_effect( terrain, "effects/material_blend4.yaml", { "parallax_mapping": False, # Not supported "alpha_testing": False, "normal_mapping": False, # The effect does its own normal mapping }, 100) # Configure the effect terrain.set_shader_input("detail_scale_factor", 4.0) # Detailmap blending factors. # Blending is calculated as (detailmap + <add>) ^ <pow> # The base map has no blending since it is used as a filling material # and blending the base map would cause spots with no material at all. terrain.set_shader_input("material_0_pow", 10.0) terrain.set_shader_input("material_0_add", 0.5) terrain.set_shader_input("material_1_pow", 10.0) terrain.set_shader_input("material_1_add", 0.5) terrain.set_shader_input("material_2_pow", 10.0) terrain.set_shader_input("material_2_add", 0.5) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(-15.2, -9.0, 11.8), Vec3(-12.3, -7.0, 9.7)) self.controller.setup()
class Application(ShowBase): """ Main Testing Showbase """ def __init__(self): # Setup window size, title and so on load_prc_file_data("", """ win-size 1600 900 window-title Render Pipeline - Material blending example """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ # Set time of day self.render_pipeline.daytime_mgr.time = "6:43" # Load the scene model = loader.loadModel("scene/Scene.bam") model.reparent_to(render) # Set the material blending effect on the terrain terrain = model.find("**/Terrain") self.render_pipeline.set_effect(terrain, "effects/material_blend4.yaml", { "parallax_mapping": False, # Not supported "alpha_testing": False, "normal_mapping": False, # The effect does its own normal mapping }, 100) # Configure the effect terrain.set_shader_input("detail_scale_factor", 4.0) # Detailmap blending factors. # Blending is calculated as (detailmap + <add>) ^ <pow> # The base map has no blending since it is used as a filling material # and blending the base map would cause spots with no material at all. terrain.set_shader_input("material_0_pow", 10.0) terrain.set_shader_input("material_0_add", 0.5) terrain.set_shader_input("material_1_pow", 10.0) terrain.set_shader_input("material_1_add", 0.5) terrain.set_shader_input("material_2_pow", 10.0) terrain.set_shader_input("material_2_add", 0.5) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(-15.2, -9.0, 11.8), Vec3(-12.3, -7.0, 9.7)) self.controller.setup()
class Application(ShowBase): def __init__(self): # Setup window size, title and so on load_prc_file_data("", """ win-size 1600 900 window-title Render Pipeline by tobspr stm-max-chunk-count 2048 gl-coordinate-system default stm-max-views 20 notify-level-linmath error """) self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # Set time of day self.render_pipeline.daytime_mgr.time = "04:25" # Add some environment probe to provide better reflections probe = self.render_pipeline.add_environment_probe() probe.set_pos(0, 0, 600) probe.set_scale(8192 * 2, 8192 * 2, 1000) self.terrain_np = render.attach_new_node("terrain") heightfield = loader.loadTexture("resources/heightfield.png") for x in range(3): for y in range(3): terrain_node = ShaderTerrainMesh() terrain_node.heightfield = heightfield terrain_node.target_triangle_width = 6.0 terrain_node.generate() terrain_n = self.terrain_np.attach_new_node(terrain_node) terrain_n.set_scale(8192, 8192, 600) terrain_n.set_pos(-4096 + (x - 1) * 8192, -4096 + (y - 1) * 8192, 0) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(-12568, -11736, 697), Vec3(-12328, -11357, 679)) self.controller.setup() self.accept("r", self.reload_shaders) self.reload_shaders() def reload_shaders(self): self.render_pipeline.reload_shaders() # Set the terrain effect self.render_pipeline.set_effect(self.terrain_np, "effects/terrain-effect.yaml", {}, 100) base.accept("l", self.tour) def tour(self): control_points = ( (Vec3(2755.62084961, 6983.76708984, 506.219055176), Vec3(-179.09147644, 4.30751991272, 0.0)), (Vec3(3153.70068359, 5865.30859375, 560.780822754), Vec3(-225.239028931, 3.43641376495, 0.0)), (Vec3(2140.57080078, 5625.22753906, 598.345031738), Vec3(-196.022613525, 1.91196918488, 0.0)), (Vec3(2598.85961914, 3820.56958008, 627.692993164), Vec3(-272.410125732, 3.32752752304, 0.0)), (Vec3(1894.64526367, 3597.39257812, 647.455078125), Vec3(-198.227630615, 0.605303645134, 0.0)), (Vec3(1998.48425293, 1870.05358887, 639.38458252), Vec3(-121.682502747, 0.169744253159, 0.0)), (Vec3(3910.55297852, 2370.70922852, 518.356567383), Vec3(-130.42376709, 3.65418696404, -0.000583928485867)), (Vec3(4830.80761719, 1542.30749512, 501.019073486), Vec3(21.7212314606, 8.00974178314, 0.0)), (Vec3(4324.81982422, 2259.2409668, 713.095458984), Vec3(-19.1500263214, -1.68137300014, 0.0)), (Vec3(4584.38720703, 3417.75073242, 612.79510498), Vec3(-39.4675331116, -4.94804239273, 0.0)), (Vec3(4569.68261719, 4840.80908203, 540.924926758), Vec3(-83.4887771606, 4.08973407745, 0.0)), (Vec3(5061.6484375, 5490.93896484, 694.142578125), Vec3(-135.778717041, 0.605291008949, 0.0)), (Vec3(6273.03222656, 6343.10546875, 769.735290527), Vec3(-200.826278687, -1.35470712185, 0.0)), (Vec3(7355.02832031, 6314.39892578, 1164.65527344), Vec3(-262.645324707, -12.2435855865, 0.0)), (Vec3(6321.42431641, 4453.68310547, 898.895202637), Vec3(-322.574157715, -2.22581481934, 0.0)), (Vec3(4820.63916016, 4637.07128906, 793.165222168), Vec3(-330.291748047, 0.931967377663, 0.0)), (Vec3(2621.3125, 4790.99072266, 691.223144531), Vec3(-423.059020996, 3.10974740982, 0.0)), (Vec3(2166.64697266, 5683.75195312, 685.415039062), Vec3(-497.871612549, -1.57248008251, 0.0)), (Vec3(2426.64135742, 7216.48974609, 993.247558594), Vec3(-524.17388916, -6.69025611877, 0.0)), (Vec3(5014.83398438, 6712.60253906, 963.192810059), Vec3(-596.072387695, -3.31469583511, 0.00446693599224)), (Vec3(6107.69970703, 5460.03662109, 820.63104248), Vec3(-650.567199707, 1.04085958004, 0.0)), ) self.controller.play_motion_path(control_points, 3.0)
class Application(ShowBase): def __init__(self): # Notice that you must not call ShowBase.__init__ (or super), the # render pipeline does that for you. If this is unconvenient for you, # have a look at the other initialization possibilities. # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes. In case you placed the render # pipeline in a subfolder of your project, you have to adjust this. sys.path.insert(0, "../../") sys.path.insert(0, "../../RenderPipeline") # Import the main render pipeline class from rpcore import RenderPipeline, SpotLight world = BulletWorld() # Construct and create the pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) from rpcore.util.movement_controller import MovementController self.render_pipeline.daytime_mgr.time = 0.769 self.controller = MovementController(self) self.controller.set_initial_position(Vec3(6.6, -18.8, 4.5), Vec3(4.7, -16.7, 3.4)) self.controller.setup() # Done! You can start setting up your application stuff as regular now. self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0 } self.speed = 1.0 base.win.setClearColor(Vec4(0, 0, 0, 1)) # # vertex_format = GeomVertexFormat.get_v3n3() # vertex_data = GeomVertexData("triangle_data", vertex_format, Geom.UH_static) # # pos_writer = GeomVertexWriter(vertex_data,"vertex") # normal_writer = GeomVertexWriter(vertex_data,"normal") # normal = Vec3(0., -1., 0.) # # pos_writer.add_data3(-1., 0., -1.) # pos_writer.add_data3(1., 0., -1.) # pos_writer.add_data3(0., 0., 1.) # # for _ in range(3): # normal_writer.add_data3(normal) # # prim = GeomTriangles(Geom.UH_static) # prim.add_vertices(0, 1, 2) # # geom = Geom(vertex_data) # geom.add_primitive(prim) # node = GeomNode("my_triangle") # node.add_geom(geom) # triangle = NodePath(node) # triangle.reparent_to(some_other_nodepath) # square1 = create_colored_rect(0, 0, 200, 200) # square2 = create_colored_rect(350, 100, 200, 200, (0, 0, 1, 1)) # square3 = create_colored_rect(-640, -360, 200, 200, (0, 1, 0, 1)) self.tr1 = create_triangle(0, 0, 0, 0, 200, 0, 0, 0, 200, (0, 1, 0, 1)) self.tr2 = create_triangle(-500, 0, 0, -300, 200, 0, -300, 0, 200, (0, 1, 0, 1)) radius = 60 height = 40 shape1 = BulletCylinderShape(radius, height, ZUp) shape2 = BulletCylinderShape(Vec3(radius, 0, 0.5 * height), ZUp) self.gnode = GeomNode('square') # gnode.addGeom(square1) # gnode.addGeom(square2) # gnode.addGeom(square3) height = 1.75 radius = 0.4 shape = BulletCapsuleShape(radius, height - 2 * radius, ZUp) self.gnode.addGeom(self.tr1) self.gnode.addGeom(self.tr2) playerNode = BulletCharacterControllerNode(shape, 0.4, 'Player') playerNP = self.render.attachNewNode(playerNode) playerNP.setPos(0, 0, 14) playerNP.setH(45) playerNP.setCollideMask(BitMask32.allOn()) world.attachCharacter(playerNP.node()) # self.tr1.setPos(400,400, 0) # self.render.attachNewNode(self.gnode) gnode2 = GeomNode('square2') textured_rect = create_textured_rect(-320, 0, 200, 280) gnode2.addGeom(textured_rect) texture = self.loader.loadTexture("assets/playte.png") ship = self.render.attachNewNode(gnode2) ship.setTransparency(TransparencyAttrib.MAlpha) ship.setTexture(texture) # self.ralph = Actor(tr1) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) self.accept("escape", sys.exit) self.accept("a", self.setKey, ["left", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("w", self.setKey, ["forward", 1]) self.accept("p", self.setKey, ["backward", 1]) self.accept("arrow_left", self.setKey, ["cam-left", 1]) self.accept("arrow_right", self.setKey, ["cam-right", 1]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("s-up", self.setKey, ["backward", 0]) self.accept("arrow_left-up", self.setKey, ["cam-left", 0]) self.accept("arrow_right-up", self.setKey, ["cam-right", 0]) self.accept("=", self.adjustSpeed, [0.25]) self.accept("+", self.adjustSpeed, [0.25]) self.accept("-", self.adjustSpeed, [-0.25]) taskMgr.add(self.move, "moveTask") # Game state variables self.isMoving = False # Set up the camera base.disableMouse() base.camera.setPos(5, 5, 0) base.camLens.setFov(80) def setKey(self, key, value): self.keyMap[key] = value # Adjust movement speed def adjustSpeed(self, delta): newSpeed = self.speed + delta if 0 <= newSpeed <= 3: self.speed = newSpeed def move(self, task): # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. # base.camera.lookAt(self.tr1) if (self.keyMap["cam-left"] != 0): base.camera.setX(base.camera, +100 * globalClock.getDt()) if (self.keyMap["cam-right"] != 0): base.camera.setX(base.camera, -100 * globalClock.getDt()) if (self.keyMap["backward"] != 0): self.gnode.removeNode() self.tr9 = create_triangle(100, 0, 0, 0, 100, 0, 0, 0, 100, (0, 1, 0, 1)) self.tr8 = create_triangle(0, 0, 0, 100, 200, 0, 200, 0, 200, (0, 1, 0, 1)) self.gnode = GeomNode('square') # gnode.addGeom(square1) # gnode.addGeom(square2) # gnode.addGeom(square3) self.gnode.addGeom(self.tr9) self.gnode.addGeom(self.tr8) # self.tr1.setPos(400,400, 0) self.render.attachNewNode(self.gnode) # startpos = self.gnode.getPos() return task.cont
class MainApp(ShowBase): def __init__(self): # Setup window size, title and so on load_prc_file_data( "", """ win-size 1600 900 window-title Render Pipeline - Car Demo """) # ------ Begin of render pipeline code ------ # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes pipeline_path = "../../" # Just a special case for my development setup, so I don't accidentally # commit a wrong path. You can remove this in your own programs. if not os.path.isfile(os.path.join(pipeline_path, "setup.py")): pipeline_path = "../../RenderPipeline/" sys.path.insert(0, pipeline_path) from rpcore import RenderPipeline, SpotLight self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # This is a helper class for better camera movement - its not really # a rendering element, but it included for convenience from rpcore.util.movement_controller import MovementController # ------ End of render pipeline code, thats it! ------ self.render_pipeline.daytime_mgr.time = "20:08" # Load the scene model = loader.loadModel("scene/scene.bam") # model = loader.loadModel("scene2/Scene.bam") model.reparent_to(render) self.render_pipeline.prepare_scene(model) # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position(Vec3(-7.5, -5.3, 1.8), Vec3(-5.9, -4.0, 1.6)) self.controller.setup() base.accept("l", self.tour) def tour(self): """ Camera flythrough """ mopath = ( (Vec3(-10.8645000458, 9.76458263397, 2.13306283951), Vec3(-133.556228638, -4.23447799683, 0.0)), (Vec3(-10.6538448334, -5.98406457901, 1.68028640747), Vec3(-59.3999938965, -3.32706642151, 0.0)), (Vec3(9.58458328247, -5.63625621796, 2.63269257545), Vec3(58.7906494141, -9.40668964386, 0.0)), (Vec3(6.8135137558, 11.0153560638, 2.25509500504), Vec3(148.762527466, -6.41223621368, 0.0)), (Vec3(-9.07093334198, 3.65908527374, 1.42396306992), Vec3(245.362503052, -3.59927511215, 0.0)), (Vec3(-8.75390911102, -3.82727789879, 0.990055501461), Vec3(296.090484619, -0.604830980301, 0.0)), ) self.controller.play_motion_path(mopath, 3.0)