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.actor = Actor('snake_mesh.b2g.gltf', {'move': 'snake_anim.b2g.gltf'})
self.actor.reparent_to(self.render)
self.actor.set_h(180)
self.actor.loop('move')
self.controller = MovementController(self)
self.controller.set_initial_position_hpr(
Vec3(0, 5, 0.8), # 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()
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()
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()
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()
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()
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()
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 - 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()
def __init__(self, app):
self.app = app
sys.path.insert(0, "./")
sys.path.insert(0, "./RenderPipeline")
from rpcore import RenderPipeline
self.render_pipeline = RenderPipeline()
self.render_pipeline.create(app)
from rpcore.util.movement_controller import MovementController
self.controller = MovementController(app)
self.controller.setup()
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 __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()
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)
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 __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 init_scene(self):
'''
Set up the movement controller and begin the motion path.
'''
# Make the motion path
mopath = ()
# Create the controller for movement
self.app.controller = MovementController(self.app)
# Set the initial position
self.app.controller.set_initial_position(Vec3(0, -57, 2),
Vec3(0, 12.5, 0))
# Run the setup on the movement controller
# self.app.controller.setup()
self.app.controller.update_task = self.app.addTask(
self.null_func, 'meh')
# Play the pre-defined motion path
self.app.controller.play_motion_path(mopath, 3)
# Remove the player movement controls
self.app.taskMgr.remove(self.app.controller.update_task)
def initScene(self): ''' Set up the movement controller and begin the motion path. ''' # Make the motion path motionPath = ( (Vec3(0, -63, 4), Vec3(0, 0, 0)), (Vec3(0, -63, 4), Vec3(0, 0, 0)), (Vec3(0, -63, 4), Vec3(0, 0, 0)), (Vec3(0, -56, 4), Vec3(-90, -10, 0)), (Vec3(0, -52, 4), Vec3(0, -70, 0)), (Vec3(0, -46, 4), Vec3(90, 0, 20)), (Vec3(0, -40, 4), Vec3(0, 0, 0)), (Vec3(0, -30, 4), Vec3(0, 0, 0)), (Vec3(0, -20, 4), Vec3(0, 0, 0)), (Vec3(5, -10, 4), Vec3(-40, 0, -5)), (Vec3(5, -9, 4), Vec3(-190, 0, 0)), (Vec3(5, -4, 4), Vec3(-190, 0, -5)), (Vec3(4, 0, 0.5), Vec3(-190, 80, 0)) ) # Create the controller for movement self.app.controller = MovementController(self.app) # Set the initial position self.app.controller.set_initial_position(Vec3(0, -63, 4), Vec3(0, 0, 0)) # Run the setup on the movement controller self.app.controller.update_task = self.app.addTask(nullTask, 'meh') # Play the pre-defined motion path self.app.controller.play_motion_path(motionPath, 0.8) # Remove the player movement controls self.app.taskMgr.remove(self.app.controller.update_task) # Unhide the 2d overlay. self.app.aspect2d.show() self.app.render2d.show() # set up the black image self.fadeQuad = OnscreenImage(image='resources/generic/fade.png',pos=(-0.5, 0, 0), scale=(2, 1, 1)) self.fadeQuad.setTransparency(TransparencyAttrib.MAlpha) # Add the fadein transition self.app.taskMgr.add(self.fadeIn, 'fade-task')
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)
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")
class MainApp(ShowBase):
def __init__(self):
# Setup window size and title
load_prc_file_data("", """
win-size 900 600
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)
# Import the movement controller, this is a convenience class
# to provide an improved camera control compared to Panda3Ds default
# mouse controller.
from rpcore.util.movement_controller import MovementController
# ------ End of render pipeline code, thats it! ------
# Set time of day
self.render_pipeline.daytime_mgr.time = "5:20"
# Configuration variables
self.half_energy = 5000
self.lamp_fov = 70
self.lamp_radius = 10
# Load the scene
model = self.loader.load_model("scene/Scene.bam")
model.reparent_to(self.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 = self.loader.load_model("panda")
panda.reparent_to(self.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.addTask(self.update, "update")
def update(self, task):
""" Update method """
frame_time = self.taskMgr.globalClock.get_frame_time()
# Make the lights glow
for i, light in enumerate(self._lights):
brightness = math.sin(0.4 * i + frame_time)
light.energy = max(0, self.half_energy / 2.0 + 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)
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 __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 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)
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 __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 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)
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()
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")
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)