class Application(ShowBase): def __init__(self): # Setup window size and title load_prc_file_data("", """ # win-size 1600 900 window-title Render Pipeline - Plugin Showcase - AO """) # Construct the render pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "19:17" # self.render_pipeline.daytime_mgr.time = "12:00" # Load the scene model = self.loader.load_model("scene/Scene.bam") model.reparent_to(self.render) self.render_pipeline.prepare_scene(model) # probe = self.render_pipeline.add_environment_probe() # probe.set_pos(0, 0, 4) # probe.set_scale(42, 42, 8) # probe.parallax_correction = True # probe.border_smoothness = 0.001 # Initialize movement controller, this is a convenience class # to provide an improved camera control compared to Panda3Ds default # mouse controller. self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(-17.2912578583, -13.290019989, 6.88211250305), Vec3(-39.7285499573, -14.6770210266, 0.0)) self.controller.setup()
class Demo(ShowBase): def __init__(self): from rpcore import RenderPipeline, PointLight from rpcore.util.movement_controller import MovementController self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = '08:00' self.point_light = PointLight() self.point_light.set_color(1, 1, 0.9) self.point_light.set_energy(10) self.point_light.set_pos(0, 5, 2) self.point_light.set_radius(20) self.render_pipeline.add_light(self.point_light) # load animations from EGG, because glTF animations aren't supported self.ruby_scene = self.loader.load_model('ruby.gltf') self.ruby = Actor(self.ruby_scene.find('+Character'), {'idle': 'ruby_anim.egg'}) self.ruby.reparent_to(self.render) self.ruby.set_h(180) self.ruby.loop('idle') self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(0, 5, 1.75), # position Vec3(180, -10, 0)) # hpr self.controller.setup()
class Demo(ShowBase): def __init__(self): from rpcore import RenderPipeline, PointLight from rpcore.util.movement_controller import MovementController self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = '08:00' self.point_light = PointLight() self.point_light.set_color(1, 1, 0.9) self.point_light.set_energy(10) self.point_light.set_pos(0, 5, 2) self.point_light.set_radius(20) self.render_pipeline.add_light(self.point_light) self.ruby = Actor('ruby.egg', {'idle': 'ruby_anim.egg'}) self.ruby.reparent_to(self.render) self.ruby.set_h(180) self.ruby.loop('idle') self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(0, 5, 1.75), # position Vec3(180, -10, 0)) # hpr self.controller.setup()
class Application(ShowBase): def __init__(self): # Setup window size and title load_prc_file_data("", """ # win-size 1600 900 window-title Render Pipeline - Material Sample """) # Construct the render pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "19:17" # self.render_pipeline.daytime_mgr.time = "12:00" # Load the scene model = self.loader.load_model("scene/TestScene.bam") model.reparent_to(self.render) self.render_pipeline.prepare_scene(model) # Enable parallax mapping on the floor # self.render_pipeline.set_effect( # model.find("**/FloorPlane"), # "effects/default.yaml", {"parallax_mapping": True}, 100) # Initialize movement controller, this is a convenience class # to provide an improved camera control compared to Panda3Ds default # mouse controller. self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(-17.2912578583, -13.290019989, 6.88211250305), Vec3(-39.7285499573, -14.6770210266, 0.0)) self.controller.setup()
class Application(ShowBase): def __init__(self): # Setup window size and title load_prc_file_data( "", """ # win-size 1600 900 window-title Render Pipeline - Material Sample """) # Construct the render pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "19:17" # self.render_pipeline.daytime_mgr.time = "12:00" # Load the scene model = self.loader.load_model("scene/TestScene.bam") model.reparent_to(self.render) self.render_pipeline.prepare_scene(model) # Enable parallax mapping on the floor # self.render_pipeline.set_effect( # model.find("**/FloorPlane"), # "effects/default.yaml", {"parallax_mapping": True}, 100) # Initialize movement controller, this is a convenience class # to provide an improved camera control compared to Panda3Ds default # mouse controller. self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(-17.2912578583, -13.290019989, 6.88211250305), Vec3(-39.7285499573, -14.6770210266, 0.0)) self.controller.setup()
class Application(ShowBase): def __init__(self): # Setup window size and title load_prc_file_data("", """ # win-size 1600 900 window-title Render Pipeline - Projected Water Example """) # Construct the render pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "19:17" # self.render_pipeline.daytime_mgr.time = "12:00" # Initialize the projected water self.water = ProjectedWater(WaterOptions) self.water.setup_water(pipeline=self.render_pipeline, water_level=-3.0) # Initialize movement controller, this is a convenience class # to provide an improved camera control compared to Panda3Ds default # mouse controller. self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(-23.2, -32.5, 5.3), Vec3(-33.8, -8.3, 0.0)) self.controller.setup()
class Demo(ShowBase): def __init__(self): from rpcore import RenderPipeline, PointLight from rpcore.util.movement_controller import MovementController self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = '08:00' self.point_light = PointLight() self.point_light.set_color(1, 1, 0.9) self.point_light.set_energy(10) self.point_light.set_pos(0, 5, 2) self.point_light.set_radius(20) self.render_pipeline.add_light(self.point_light) self.ruby = Actor('ruby_mesh.gltf', {'idle': 'ruby_anim.egg'}) self.ruby.reparent_to(self.render) self.ruby.set_h(180) self.ruby.loop('idle') self.render_pipeline.set_effect(self.ruby, 'hardware_skinning.yaml', options={}, sort=25) sattrib = self.ruby.get_attrib(ShaderAttrib) sattrib = sattrib.set_flag(ShaderAttrib.F_hardware_skinning, True) self.ruby.set_attrib(sattrib) self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(0, 5, 1.75), # position Vec3(180, -10, 0)) # hpr 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 - Material Sample """) self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) # Set time of day self.render_pipeline.daytime_mgr.time = "19:17" # Load the scene model = loader.load_model("scene/TestScene.bam") model.reparent_to(render) self.render_pipeline.prepare_scene(model) # Enable parallax mapping on the floor self.render_pipeline.set_effect(model.find("**/FloorPlane"), "effects/default.yaml", {"parallax_mapping": True}, 100) # Initialize movement controller self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(-17.2912578583, -13.290019989, 6.88211250305), Vec3(-39.7285499573, -14.6770210266, 0.0)) self.controller.setup()
class Application(ShowBase): def __init__(self): # Setup window size and title load_prc_file_data( "", """ # win-size 1600 900 window-title Render Pipeline - Instancing Example """, ) # Construct the render pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "19:17" # self.render_pipeline.daytime_mgr.time = "12:00" # Load the scene model = self.loader.load_model("scene/Scene.bam") model.reparent_to(self.render) # Find the prefab object, we are going to in instance this object # multiple times prefab = model.find("**/InstancedObjectPrefab") # Collect all instances matrices = [] for elem in model.find_all_matches("**/PREFAB*"): matrices.append(elem.get_mat(self.render)) elem.remove_node() print("Loaded", len(matrices), "instances!") # Allocate storage for the matrices, each matrix has 16 elements, # but because one pixel has four components, we need amount * 4 pixels. buffer_texture = Texture() buffer_texture.setup_buffer_texture(len(matrices) * 4, Texture.T_float, Texture.F_rgba32, GeomEnums.UH_static) float_size = len(struct.pack("f", 0.0)) floats = [] # Serialize matrices to floats ram_image = buffer_texture.modify_ram_image() for idx, mat in enumerate(matrices): for i in range(4): for j in range(4): floats.append(mat.get_cell(i, j)) # Write the floats to the texture data = struct.pack("f" * len(floats), *floats) ram_image.set_subdata(0, len(data), data) # Load the effect self.render_pipeline.set_effect(prefab, "effects/basic_instancing.yaml", {}) prefab.set_shader_input("InstancingData", buffer_texture) prefab.set_instance_count(len(matrices)) # We have do disable culling, so that all instances stay visible prefab.node().set_bounds(OmniBoundingVolume()) prefab.node().set_final(True) # Initialize movement controller, this is a convenience class # to provide an improved camera control compared to Panda3Ds default # mouse controller. self.controller = MovementController(self) self.controller.set_initial_position_hpr(Vec3(-23.2, -32.5, 5.3), Vec3(-33.8, -8.3, 0.0)) self.controller.setup()
class App(ShowBase): def __init__(self): """ Inits the showbase """ # Load options load_prc_file_data("", """ model-cache-dir fullscreen #f win-size 1920 1080 window-title Render Pipeline by tobspr icon-filename dataGUI/icon.ico """) # Load render pipeline self.render_pipeline = RenderPipeline(self) self.render_pipeline.create() # Init movement controller self.controller = MovementController(self) self.controller.set_initial_position_hpr( Vec3(-987.129, -2763.58, 211.47), Vec3(5.21728, 7.84863, 0)) self.controller.setup() # Hotkeys self.accept("r", self._reload_shader) self.addTask(self.update, "update") self.scene_wireframe = False self._init_terrain() self._reload_shader() def update(self, task): """ Main update task """ self.terrain.update() self.terrain_shadow.update() return task.cont def _reload_shader(self): """ Reloads all terrain shaders """ self.render_pipeline.reload_shaders() self.render_pipeline.set_effect(self.terrain.get_node(), "effects/terrain.yaml", { "render_gbuffer": True, "render_shadows": False, }) self.render_pipeline.set_effect(self.terrain_shadow.get_node(), "effects/terrain_shadow.yaml", { "render_gbuffer": False, "render_shadows": True, }, 5000) def _init_terrain(self): """ Inits the terrain """ layout = "Layout0" hmap = "data/terrain/" + layout + "/heightmap.png" bounds_file = "data/terrain/" + layout + "bounds.bin" if not isfile(bounds_file): print("Generating terrain bounds ..") TerrainMeshRenderer.generate_bounds(hmap, "data/Terrain/" + layout + "bounds.bin") terrainOffset = Vec3(-4096, -4096, 70.0) terrainScale = Vec3(1.0, 1.0, 700.0) self.terrain = TerrainMeshRenderer() self.terrain.set_heightfield_size(8192) self.terrain.set_culling_enabled(False) self.terrain.load_chunk_mesh("core/resources/Chunk32.bam") self.terrain.set_focus(base.cam, base.camLens) self.terrain.load_bounds(bounds_file) self.terrain.set_target_triangle_width(7.0) self.terrain.set_pos(terrainOffset) self.terrain.set_scale(terrainScale) self.terrain.create() node = self.terrain.get_node() node.reparentTo(render) self.terrain_shadow = TerrainMeshRenderer() self.terrain_shadow.set_heightfield_size(8192) self.terrain_shadow.load_chunk_mesh("core/resources/Chunk32.bam") self.terrain_shadow.set_focus(base.cam, base.camLens) self.terrain_shadow.set_target_triangle_width(7.0) self.terrain_shadow.load_bounds(bounds_file) self.terrain_shadow.set_pos(terrainOffset) self.terrain_shadow.set_scale(terrainScale) self.terrain_shadow.set_culling_enabled(False) self.terrain_shadow.create() nodeShadow = self.terrain_shadow.get_node() nodeShadow.reparentTo(render) hmap = loader.loadTexture("data/terrain/" + layout + "/heightmap.png") hmap.set_wrap_u(Texture.WM_clamp) hmap.set_wrap_v(Texture.WM_clamp) hmap.set_format(Texture.F_r16) node.set_shader_input("heightmap", hmap) nodeShadow.set_shader_input("heightmap", hmap) fmap = loader.loadTexture("data/terrain/" + layout + "/flowmap.png") fmap.set_wrap_u(Texture.WMClamp) fmap.set_wrap_v(Texture.WMClamp) node.set_shader_input("flowmap", fmap) for material in ['rock', 'grass', 'gravel', 'snow', 'moss']: for i in xrange(2): tex = loader.loadTexture("data/terrain/Materials/" + material + "_" + str(i+1) + ".png") tex.set_wrap_u(Texture.WM_repeat) tex.set_wrap_v(Texture.WM_repeat) tex.set_format(Texture.F_srgb_alpha) tex.set_minfilter(Texture.FT_linear_mipmap_linear) tex.set_magfilter(Texture.FT_linear) tex.set_anisotropic_degree(16) node.set_shader_input(material + ("Diffuse" if i == 0 else "Normal"), tex)