def _late_init(self, task):
""" Gets called after the pipeline was initialized """
self._display_txt = Text(
text="40 ms", parent=self._node, x=20, y=25,
size=13, color=Vec3(1), may_change=True)
self._display_txt_bottom = Text(
text="0 ms", parent=self._node, x=20, y=120,
size=13, color=Vec3(1), may_change=True)
# Create the shader which generates the visualization texture
self._cshader_node = ComputeNode("FPSChartUpdateChart")
self._cshader_node.add_dispatch(250 // 10, 120 // 4, 1)
self._cshader_np = self._node.attach_new_node(self._cshader_node)
self._cshader = RPLoader.load_shader("/$$rp/shader/fps_chart.compute.glsl")
self._cshader_np.set_shader(self._cshader)
self._cshader_np.set_shader_input("DestTex", self._display_tex)
self._cshader_np.set_shader_input("FPSValues", self._storage_buffer)
self._cshader_np.set_shader_input("index", self._store_index)
self._cshader_np.set_shader_input("maxMs", self._chart_ms_max)
self._update_shader_node = ComputeNode("FPSChartUpdateValues")
self._update_shader_node.add_dispatch(1, 1, 1)
self._update_shader_np = self._node.attach_new_node(self._update_shader_node)
self._ushader = RPLoader.load_shader("/$$rp/shader/fps_chart_update.compute.glsl")
self._update_shader_np.set_shader(self._ushader)
self._update_shader_np.set_shader_input("DestTex", self._storage_buffer)
self._update_shader_np.set_shader_input("index", self._store_index)
self._update_shader_np.set_shader_input("currentData", self._current_ftime)
Globals.base.addTask(self._update, "UpdateFPSChart", sort=-50)
return task.done
def on_pipeline_created(self):
cloud_voxels = RPLoader.load_3d_texture(self.get_resource("slices/#.png"))
cloud_voxels.set_wrap_w(SamplerState.WM_clamp)
self.apply_stage.set_shader_input("CloudVoxels", cloud_voxels)
noise_tex = RPLoader.load_texture(self.get_resource("noise.png"))
noise_tex.set_minfilter(SamplerState.FT_linear_mipmap_linear)
self.apply_stage.set_shader_input("NoiseTex", noise_tex)
def __init__(self,
parent=None,
x=0,
y=0,
callback=None,
extra_args=None,
radio=False,
expand_width=100,
checked=False,
enabled=True):
RPObject.__init__(self)
prefix = "checkbox" if not radio else "radiobox"
if enabled:
checked_img = RPLoader.load_texture("/$$rp/data/gui/" + prefix +
"_checked.png")
unchecked_img = RPLoader.load_texture("/$$rp/data/gui/" + prefix +
"_default.png")
else:
checked_img = RPLoader.load_texture("/$$rp/data/gui/" + prefix +
"_disabled.png")
unchecked_img = checked_img
# Set near filter, otherwise textures look like crap
for tex in [checked_img, unchecked_img]:
tex.set_minfilter(SamplerState.FT_linear)
tex.set_magfilter(SamplerState.FT_linear)
tex.set_wrap_u(SamplerState.WM_clamp)
tex.set_wrap_v(SamplerState.WM_clamp)
tex.set_anisotropic_degree(0)
self._node = DirectCheckBox(parent=parent,
pos=(x + 11, 1, -y - 8),
scale=(10 / 2.0, 1, 10 / 2.0),
checkedImage=checked_img,
uncheckedImage=unchecked_img,
image=unchecked_img,
extraArgs=extra_args,
state=DGG.NORMAL,
relief=DGG.FLAT,
command=self._update_status)
self._node["frameColor"] = (0, 0, 0, 0)
self._node["frameSize"] = (-2.6, 2 + expand_width / 7.5, -2.35, 2.5)
self._node.set_transparency(TransparencyAttrib.M_alpha)
self._callback = callback
self._extra_args = extra_args
self._collection = None
if checked:
self.set_checked(True, False)
def _load_textures(self):
""" Loads all required textures """
search_tex = RPLoader.load_texture(self.get_resource("search_tex.png"))
area_tex = RPLoader.load_texture(self.get_resource("area_tex.png"))
for tex in [search_tex, area_tex]:
tex.set_minfilter(SamplerState.FT_linear)
tex.set_magfilter(SamplerState.FT_linear)
tex.set_wrap_u(SamplerState.WM_clamp)
tex.set_wrap_v(SamplerState.WM_clamp)
self._smaa_stage.area_tex = area_tex
self._smaa_stage.search_tex = search_tex
def _load_textures(self):
""" Loads all required textures """
search_tex = RPLoader.load_texture(self.get_resource("search_tex.png"))
area_tex = RPLoader.load_texture(self.get_resource("area_tex.png"))
for tex in [search_tex, area_tex]:
tex.set_minfilter(SamplerState.FT_linear)
tex.set_magfilter(SamplerState.FT_linear)
tex.set_wrap_u(SamplerState.WM_clamp)
tex.set_wrap_v(SamplerState.WM_clamp)
self._smaa_stage.area_tex = area_tex
self._smaa_stage.search_tex = search_tex
def _load_skydome(self):
""" Loads the skydome """
skydome = RPLoader.load_texture(
"/$$rp/data/builtin_models/skybox/skybox.txo")
skydome.set_wrap_u(SamplerState.WM_clamp)
skydome.set_wrap_v(SamplerState.WM_clamp)
self._pipeline.stage_mgr.inputs["DefaultSkydome"] = skydome
def __init__(self,
font="/$$rp/rpcore/data/font/Roboto-Bold.ttf",
pixel_size=16,
align="left",
pos=Vec2(0),
color=Vec3(1),
parent=None):
""" Constructs a new text node, forwaring the parameters to the internal
panda3d implementation """
RPObject.__init__(self)
self._node = TextNodeImpl('FTN')
self._node.set_text("")
self._node.set_align(getattr(TextNodeImpl, "A_" + align))
self._node.set_text_color(color.x, color.y, color.z, 1)
if parent is None:
parent = Globals.base.aspect2d
self._nodepath = parent.attach_new_node(self._node)
self._nodepath.set_pos(pos.x, 0, pos.y)
font = RPLoader.load_font(font)
# font.set_outline(Vec4(0, 0, 0, 0.78), 1.6, 0.37)
font.set_outline(Vec4(0, 0, 0, 1), 1.6, 0.37)
font.set_scale_factor(1.0)
font.set_texture_margin(int(pixel_size / 4.0 * 2.0))
font.set_bg(Vec4(0, 0, 0, 0))
self._node.set_font(font)
self.set_pixel_size(pixel_size)
def _load_fonts(self):
""" Loads the default font used for rendering and assigns it to
Globals.font for further usage """
Globals.font = RPLoader.load_font("/$$rp/data/font/roboto-medium.ttf")
Globals.font.set_pixels_per_unit(35)
Globals.font.set_poly_margin(0.0)
Globals.font.set_texture_margin(1)
def _late_init(self, task):
""" Gets called after the pipeline got initialized """
scene_tex = self._pipeline.stage_mgr.pipes["ShadedScene"]
self._zoomer.set_shader(RPLoader.load_shader(
"/$$rp/shader/default_gui_shader.vert.glsl",
"/$$rp/shader/pixel_inspector.frag.glsl"))
self._zoomer.set_shader_input("SceneTex", scene_tex)
return task.done
def _load_grain(self):
grain_tex = RPLoader.load_texture("/$$rp/data/film_grain/grain.txo")
grain_tex.set_minfilter(SamplerState.FT_linear)
grain_tex.set_magfilter(SamplerState.FT_linear)
grain_tex.set_wrap_u(SamplerState.WM_repeat)
grain_tex.set_wrap_v(SamplerState.WM_repeat)
grain_tex.set_anisotropic_degree(0)
self._stage.set_shader_input("PrecomputedGrain", grain_tex)
def _late_init(self, task):
""" Gets called after the pipeline got initialized """
scene_tex = self._pipeline.stage_mgr.pipes["ShadedScene"]
self._zoomer.set_shader(
RPLoader.load_shader("/$$rp/shader/default_gui_shader.vert.glsl",
"/$$rp/shader/pixel_inspector.frag.glsl"))
self._zoomer.set_shader_input("SceneTex", scene_tex)
return task.done
def _late_init(self, task):
""" Gets called after the pipeline was initialized """
self._display_txt = Text(text="40 ms",
parent=self._node,
x=20,
y=25,
size=13,
color=Vec3(1),
may_change=True)
self._display_txt_bottom = Text(text="0 ms",
parent=self._node,
x=20,
y=120,
size=13,
color=Vec3(1),
may_change=True)
# Create the shader which generates the visualization texture
self._cshader_node = ComputeNode("FPSChartUpdateChart")
self._cshader_node.add_dispatch(250 // 10, 120 // 4, 1)
self._cshader_np = self._node.attach_new_node(self._cshader_node)
self._cshader = RPLoader.load_shader(
"/$$rp/shader/fps_chart.compute.glsl")
self._cshader_np.set_shader(self._cshader)
self._cshader_np.set_shader_input("DestTex", self._display_tex)
self._cshader_np.set_shader_input("FPSValues", self._storage_buffer)
self._cshader_np.set_shader_input("index", self._store_index)
self._cshader_np.set_shader_input("maxMs", self._chart_ms_max)
self._update_shader_node = ComputeNode("FPSChartUpdateValues")
self._update_shader_node.add_dispatch(1, 1, 1)
self._update_shader_np = self._node.attach_new_node(
self._update_shader_node)
self._ushader = RPLoader.load_shader(
"/$$rp/shader/fps_chart_update.compute.glsl")
self._update_shader_np.set_shader(self._ushader)
self._update_shader_np.set_shader_input("DestTex",
self._storage_buffer)
self._update_shader_np.set_shader_input("index", self._store_index)
self._update_shader_np.set_shader_input("currentData",
self._current_ftime)
Globals.base.addTask(self._update, "UpdateFPSChart", sort=-50)
return task.done
def __init__(self,
image=None,
parent=None,
x=0,
y=0,
w=None,
h=None,
transparent=True,
near_filter=True,
any_filter=True):
""" Creates a new image, taking (x,y) as topleft coordinates.
When near_filter is set to true, a near filter will be set to the
texture passed. This provides sharper images.
When any_filter is set to false, the passed image won't be modified at
all. This enables you to display existing textures, otherwise the
texture would get a near filter in the 3D View, too. """
RPObject.__init__(self)
if not isinstance(image, Texture):
if not isinstance(image, str):
self.warn("Invalid argument to image parameter:", image)
return
image = RPLoader.load_texture(image)
if w is None or h is None:
w, h = image.get_x_size(), image.get_y_size()
else:
if w is None or h is None:
w = 10
h = 10
self._width, self._height = w, h
self._initial_pos = self._translate_pos(x, y)
self.node = OnscreenImage(image=image,
parent=parent,
pos=self._initial_pos,
scale=(self._width / 2.0, 1,
self._height / 2.0))
if transparent:
self.node.set_transparency(TransparencyAttrib.M_alpha)
tex = self.node.get_texture()
# Apply a near filter, but only if the parent has no scale, otherwise
# it will look weird
if near_filter and any_filter and parent.get_sx() == 1.0:
tex.set_minfilter(SamplerState.FT_nearest)
tex.set_magfilter(SamplerState.FT_nearest)
if any_filter:
tex.set_anisotropic_degree(8)
tex.set_wrap_u(SamplerState.WM_clamp)
tex.set_wrap_v(SamplerState.WM_clamp)
def _load_grain(self):
grain_tex = RPLoader.load_texture(
"/$$rp/data/film_grain/grain.txo")
grain_tex.set_minfilter(SamplerState.FT_linear)
grain_tex.set_magfilter(SamplerState.FT_linear)
grain_tex.set_wrap_u(SamplerState.WM_repeat)
grain_tex.set_wrap_v(SamplerState.WM_repeat)
grain_tex.set_anisotropic_degree(0)
self._stage.set_shader_input("PrecomputedGrain", grain_tex)
def _load_fonts(self):
""" Loads the default font used for rendering and assigns it to
Globals.font for further usage """
Globals.font = RPLoader.load_font("/$$rp/data/font/roboto-medium.ttf")
Globals.font.set_pixels_per_unit(35)
Globals.font.set_poly_margin(0.0)
Globals.font.set_texture_margin(1)
Globals.font.set_bg(Vec4(1, 1, 1, 0))
Globals.font.set_fg(Vec4(1, 1, 1, 1))
def _load_fonts(self):
""" Loads the default font used for rendering and assigns it to
Globals.font for further usage """
font = RPLoader.load_font("/$$rp/data/font/Roboto-Medium.ttf")
font.set_pixels_per_unit(35)
font.set_poly_margin(0.0)
font.set_texture_margin(1)
font.set_bg(Vec4(1, 1, 1, 0))
font.set_fg(Vec4(1, 1, 1, 1))
Globals.font = font
def create_shaders(self):
""" Creates all the shaders used for precomputing """
self.shaders = {}
resource_path = self.handle.get_shader_resource("eric_bruneton")
for fname in listdir(resource_path):
fpath = join(resource_path, fname)
if isfile(fpath) and fname.endswith(".compute.glsl"):
shader_name = fname.split(".")[0]
shader_obj = RPLoader.load_shader(fpath)
self.shaders[shader_name] = shader_obj
def load_grain(self):
""" Loads the precomputed film grain """
grain_tex = RPLoader.load_texture(
"/$$rp/rpcore/data/film_grain/grain.txo.pz")
grain_tex.set_minfilter(SamplerState.FT_linear)
grain_tex.set_magfilter(SamplerState.FT_linear)
grain_tex.set_wrap_u(SamplerState.WM_repeat)
grain_tex.set_wrap_v(SamplerState.WM_repeat)
grain_tex.set_anisotropic_degree(0)
self.stage.set_shader_input("PrecomputedGrain", grain_tex)
def create_shaders(self):
""" Creates all the shaders used for precomputing """
self.shaders = {}
resource_path = self.handle.get_shader_resource("eric_bruneton")
for fname in listdir(resource_path):
fpath = join(resource_path, fname)
if isfile(fpath) and fname.endswith(".compute.glsl"):
shader_name = fname.split(".")[0]
shader_obj = RPLoader.load_shader(fpath)
self.shaders[shader_name] = shader_obj
def load_lut(self):
""" Loads the color correction lookup table (LUT) """
lut_path = self.get_resource(self.get_setting("color_lut"))
lut = RPLoader.load_sliced_3d_texture(lut_path, 64)
lut.set_wrap_u(SamplerState.WM_clamp)
lut.set_wrap_v(SamplerState.WM_clamp)
lut.set_wrap_w(SamplerState.WM_clamp)
lut.set_minfilter(SamplerState.FT_linear)
lut.set_magfilter(SamplerState.FT_linear)
lut.set_anisotropic_degree(0)
self.tonemapping_stage.set_shader_input("ColorLUT", lut)
def _load_lut(self):
""" Loads the color correction lookup table (LUT) """
lut_path = self.get_resource(self.get_setting("color_lut"))
lut = RPLoader.load_sliced_3d_texture(lut_path, 64)
lut.set_wrap_u(SamplerState.WM_clamp)
lut.set_wrap_v(SamplerState.WM_clamp)
lut.set_wrap_w(SamplerState.WM_clamp)
lut.set_minfilter(SamplerState.FT_linear)
lut.set_magfilter(SamplerState.FT_linear)
lut.set_anisotropic_degree(0)
self._tonemapping_stage.set_shader_input("ColorLUT", lut)
def _load_environment_cubemap(self):
""" Loads the default cubemap used for the environment, which is used
when no other environment data is available """
envmap = RPLoader.load_cube_map(
"/$$rp/data/default_cubemap/cubemap.txo", read_mipmaps=True)
envmap.set_minfilter(SamplerState.FT_linear_mipmap_linear)
# envmap.set_format(Image.F_rgba16)
envmap.set_magfilter(SamplerState.FT_linear)
envmap.set_wrap_u(SamplerState.WM_repeat)
envmap.set_wrap_v(SamplerState.WM_repeat)
envmap.set_wrap_w(SamplerState.WM_repeat)
self._pipeline.stage_mgr.inputs["DefaultEnvmap"] = envmap
def create_shaders(self):
""" Creates all the shaders used for precomputing """
self.shaders = {}
for i in files('render-pipeline'):
if len(i.parts) == 5 and '/'.join(
i.parts[:4]
) == 'rpplugins/scattering/shader/eric_bruneton':
fname = i.parts[4]
if fname.endswith('.compute.glsl'):
shader_name = fname.split(".")[0]
shader_obj = RPLoader.load_shader('/'.join(i.parts))
self.shaders[shader_name] = shader_obj
def _load_environment_cubemap(self):
""" Loads the default cubemap used for the environment, which is used
when no other environment data is available """
envmap = RPLoader.load_cube_map(
"/$$rp/data/default_cubemap/cubemap.txo", read_mipmaps=True)
envmap.set_minfilter(SamplerState.FT_linear_mipmap_linear)
# envmap.set_format(Image.F_rgba16)
envmap.set_magfilter(SamplerState.FT_linear)
envmap.set_wrap_u(SamplerState.WM_repeat)
envmap.set_wrap_v(SamplerState.WM_repeat)
envmap.set_wrap_w(SamplerState.WM_repeat)
self._pipeline.stage_mgr.inputs["DefaultEnvmap"] = envmap
def __init__(self, parent=None, x=0, y=0, callback=None, extra_args=None,
radio=False, expand_width=100, checked=False, enabled=True):
RPObject.__init__(self)
prefix = "checkbox" if not radio else "radiobox"
if enabled:
checked_img = RPLoader.load_texture(
"/$$rp/data/gui/" + prefix + "_checked.png")
unchecked_img = RPLoader.load_texture(
"/$$rp/data/gui/" + prefix + "_default.png")
else:
checked_img = RPLoader.load_texture(
"/$$rp/data/gui/" + prefix + "_disabled.png")
unchecked_img = checked_img
# Set near filter, otherwise textures look like crap
for tex in [checked_img, unchecked_img]:
tex.set_minfilter(SamplerState.FT_linear)
tex.set_magfilter(SamplerState.FT_linear)
tex.set_wrap_u(SamplerState.WM_clamp)
tex.set_wrap_v(SamplerState.WM_clamp)
tex.set_anisotropic_degree(0)
self._node = DirectCheckBox(
parent=parent, pos=(x + 11, 1, -y - 8), scale=(10 / 2.0, 1, 10 / 2.0),
checkedImage=checked_img, uncheckedImage=unchecked_img,
image=unchecked_img, extraArgs=extra_args, state=DGG.NORMAL,
relief=DGG.FLAT, command=self._update_status)
self._node["frameColor"] = (0, 0, 0, 0)
self._node["frameSize"] = (-2.6, 2 + expand_width / 7.5, -2.35, 2.5)
self._node.set_transparency(TransparencyAttrib.M_alpha)
self._callback = callback
self._extra_args = extra_args
self._collection = None
if checked:
self.set_checked(True, False)
def on_pipeline_created(self):
# High-res noise
noise1 = RPLoader.load_texture(self.get_resource("noise1-data.txo"))
noise1.set_wrap_u(SamplerState.WM_repeat)
noise1.set_wrap_v(SamplerState.WM_repeat)
noise1.set_wrap_w(SamplerState.WM_repeat)
noise1.set_minfilter(SamplerState.FT_linear_mipmap_linear)
self.apply_stage.set_shader_input("Noise1", noise1)
# Low-res noise
noise2 = RPLoader.load_texture(self.get_resource("noise2-data.txo"))
noise2.set_wrap_u(SamplerState.WM_repeat)
noise2.set_wrap_v(SamplerState.WM_repeat)
noise2.set_wrap_w(SamplerState.WM_repeat)
noise2.set_minfilter(SamplerState.FT_linear_mipmap_linear)
self.apply_stage.set_shader_input("Noise2", noise2)
# Weather tex
weather = RPLoader.load_texture(self.get_resource("weather_tex.png"))
weather.set_wrap_u(SamplerState.WM_repeat)
weather.set_wrap_v(SamplerState.WM_repeat)
self.apply_stage.set_shader_input("WeatherTex", weather)
def on_pipeline_created(self):
# High-res noise
noise1 = RPLoader.load_texture(self.get_resource("noise1-data.txo.pz"))
noise1.set_wrap_u(SamplerState.WM_repeat)
noise1.set_wrap_v(SamplerState.WM_repeat)
noise1.set_wrap_w(SamplerState.WM_repeat)
noise1.set_minfilter(SamplerState.FT_linear_mipmap_linear)
self.apply_stage.set_shader_input("Noise1", noise1)
# Low-res noise
noise2 = RPLoader.load_texture(self.get_resource("noise2-data.txo.pz"))
noise2.set_wrap_u(SamplerState.WM_repeat)
noise2.set_wrap_v(SamplerState.WM_repeat)
noise2.set_wrap_w(SamplerState.WM_repeat)
noise2.set_minfilter(SamplerState.FT_linear_mipmap_linear)
self.apply_stage.set_shader_input("Noise2", noise2)
# Weather tex
weather = RPLoader.load_texture(self.get_resource("weather_tex.png"))
weather.set_wrap_u(SamplerState.WM_repeat)
weather.set_wrap_v(SamplerState.WM_repeat)
self.apply_stage.set_shader_input("WeatherTex", weather)
def __init__(self, image=None, parent=None, x=0, y=0, w=None, h=None,
transparent=True, near_filter=True, any_filter=True):
""" Creates a new image, taking (x,y) as topleft coordinates.
When near_filter is set to true, a near filter will be set to the
texture passed. This provides sharper images.
When any_filter is set to false, the passed image won't be modified at
all. This enables you to display existing textures, otherwise the
texture would get a near filter in the 3D View, too. """
RPObject.__init__(self)
if not isinstance(image, Texture):
if not isinstance(image, str):
self.warn("Invalid argument to image parameter:", image)
return
image = RPLoader.load_texture(image)
if w is None or h is None:
w, h = image.get_x_size(), image.get_y_size()
else:
if w is None or h is None:
w = 10
h = 10
self._width, self._height = w, h
self._initial_pos = self._translate_pos(x, y)
self.node = OnscreenImage(
image=image, parent=parent, pos=self._initial_pos,
scale=(self._width / 2.0, 1, self._height / 2.0))
if transparent:
self.node.set_transparency(TransparencyAttrib.M_alpha)
tex = self.node.get_texture()
# Apply a near filter, but only if the parent has no scale, otherwise
# it will look weird
if near_filter and any_filter and parent.get_sx() == 1.0:
tex.set_minfilter(SamplerState.FT_nearest)
tex.set_magfilter(SamplerState.FT_nearest)
if any_filter:
tex.set_anisotropic_degree(8)
tex.set_wrap_u(SamplerState.WM_clamp)
tex.set_wrap_v(SamplerState.WM_clamp)
def do_load(self, filename):
""" Internal method to load the effect from the given filename, do
not use this directly, instead use load(). """
self.filename = filename
self.effect_name = self._convert_filename_to_name(filename)
self.effect_hash = self._generate_hash(filename, self._options)
# Load the YAML file
parsed_yaml = load_yaml_file(filename) or {}
self._parse_content(parsed_yaml)
# Construct a shader object for each pass
for pass_id in self._PASSES:
vertex_src = self._generated_shader_paths["vertex-" + pass_id]
fragment_src = self._generated_shader_paths["fragment-" + pass_id]
self._shader_objs[pass_id] = RPLoader.load_shader(vertex_src, fragment_src)
return True
def do_load(self, filename):
""" Internal method to load the effect from the given filename, do
not use this directly, instead use load(). """
self.filename = filename
self.effect_name = self._convert_filename_to_name(filename)
self.effect_hash = self._generate_hash(filename, self._options)
# Load the YAML file
parsed_yaml = load_yaml_file(filename) or {}
self._parse_content(parsed_yaml)
# Construct a shader object for each pass
for pass_id in self._PASSES:
vertex_src = self._generated_shader_paths["vertex-" + pass_id]
fragment_src = self._generated_shader_paths["fragment-" + pass_id]
self._shader_objs[pass_id] = RPLoader.load_shader(
vertex_src, fragment_src)
return True
def _late_init(self, task):
""" Gets called after the pipeline initialized, this extracts the
exposure texture from the stage manager """
stage_mgr = self._pipeline.stage_mgr
if "Exposure" not in stage_mgr.pipes:
self.debug("Disabling exposure widget, could not find the exposure data.")
self._node.remove_node()
return
self._node.show()
exposure_tex = stage_mgr.pipes["Exposure"]
self._cshader = RPLoader.load_shader("/$$rp/shader/visualize_exposure.compute.glsl")
self._cshader_np.set_shader(self._cshader)
self._cshader_np.set_shader_input("DestTex", self._storage_tex)
self._cshader_np.set_shader_input("ExposureTex", exposure_tex)
return task.done
def _late_init(self, task):
""" Gets called after the pipeline initialized, this extracts the
exposure texture from the stage manager """
stage_mgr = self._pipeline.stage_mgr
if "Exposure" not in stage_mgr.pipes:
self.debug("Disabling exposure widget, could not find the exposure data.")
self._node.remove_node()
return
self._node.show()
exposure_tex = stage_mgr.pipes["Exposure"]
self._cshader = RPLoader.load_shader("/$$rp/shader/visualize_exposure.compute.glsl")
self._cshader_np.set_shader(self._cshader)
self._cshader_np.set_shader_input("DestTex", self._storage_tex)
self._cshader_np.set_shader_input("ExposureTex", exposure_tex)
return task.done
def build(cls, texture, view_width, view_height):
""" Builds a shader to display <texture> in a view port with the size
<view_width> * <view_height> """
view_width, view_height = int(view_width), int(view_height)
cache_key = "/$$rptemp/$$TEXDISPLAY-X{}-Y{}-Z{}-TT{}-CT{}-VW{}-VH{}.frag.glsl".format(
texture.get_x_size(), texture.get_y_size(), texture.get_z_size(),
texture.get_texture_type(), texture.get_component_type(),
view_width, view_height)
# Only regenerate the file when there is no cache entry for it
if not isfile(cache_key) or True:
fragment_shader = cls._build_fragment_shader(
texture, view_width, view_height)
with open(cache_key, "w") as handle:
handle.write(fragment_shader)
return RPLoader.load_shader(
"/$$rp/shader/default_gui_shader.vert.glsl", cache_key)
def _get_shader_handle(self, path, *args):
""" Returns a handle to a Shader object, containing all sources passed
as arguments. The path argument will be used to locate shaders if no
absolute path is given. This is the internal method used in load_shader
and load_plugin_shader. """
assert len(args) > 0 and len(args) <= 3
path_args = []
for source in args:
for prefix in ("/$$rpconfig", "/$$rp/shader", "/$$rptemp"):
if prefix in source:
path_args.append(source)
break
else:
path_args.append(path.format(source))
# If only one shader is specified, assume its a postprocess fragment shader,
# and use the default vertex shader
if len(args) == 1:
path_args = ["/$$rp/shader/default_post_process.vert.glsl"] + path_args
return RPLoader.load_shader(*path_args)
def load(self):
""" Loads the scattering method """
lut_src = self.handle.get_resource(
"hosek_wilkie_scattering/scattering_lut.txo")
if not isfile(lut_src):
self.error("Could not find precompiled LUT for the Hosek Wilkie "
"Scattering! Make sure you compiled the algorithm code!")
return
lut_tex = RPLoader.load_sliced_3d_texture(lut_src, 512, 128, 100)
lut_tex.set_wrap_u(SamplerState.WM_repeat)
lut_tex.set_wrap_v(SamplerState.WM_clamp)
lut_tex.set_wrap_w(SamplerState.WM_clamp)
lut_tex.set_minfilter(SamplerState.FT_linear)
lut_tex.set_magfilter(SamplerState.FT_linear)
# Setting the format explicitely shouldn't be necessary
# lut_tex.set_format(Image.F_rgb16)
self.handle.display_stage.set_shader_input("ScatteringLUT", lut_tex)
self.handle.envmap_stage.set_shader_input("ScatteringLUT", lut_tex)
def load(self):
""" Loads the scattering method """
lut_src = self.handle.get_resource(
"HosekWilkieScattering/scattering_luit.png")
if not isfile(lut_src):
self.error("Could not find precompiled LUT for the Hosek Wilkie "
"Scattering! Make sure you compiled the algorithm code!")
return
lut_tex = RPLoader.load_sliced_3d_texture(lut_src, 512, 128, 100)
lut_tex.set_wrap_u(SamplerState.WM_repeat)
lut_tex.set_wrap_v(SamplerState.WM_clamp)
lut_tex.set_wrap_w(SamplerState.WM_clamp)
lut_tex.set_minfilter(SamplerState.FT_linear)
lut_tex.set_magfilter(SamplerState.FT_linear)
# Setting the format explicitely shouldn't be necessary
# lut_tex.set_format(Image.F_rgb16)
self.handle.display_stage.set_shader_input("ScatteringLUT", lut_tex)
self.handle.envmap_stage.set_shader_input("ScatteringLUT", lut_tex)
def build(cls, texture, view_width, view_height):
""" Builds a shader to display <texture> in a view port with the size
<view_width> * <view_height> """
view_width, view_height = int(view_width), int(view_height)
cache_key = "/$$rptemp/$$TEXDISPLAY-X{}-Y{}-Z{}-TT{}-CT{}-VW{}-VH{}.frag.glsl".format(
texture.get_x_size(),
texture.get_y_size(),
texture.get_z_size(),
texture.get_texture_type(),
texture.get_component_type(),
view_width,
view_height)
# Only regenerate the file when there is no cache entry for it
if not isfile(cache_key) or True:
fragment_shader = cls._build_fragment_shader(texture, view_width, view_height)
with open(cache_key, "w") as handle:
handle.write(fragment_shader)
return RPLoader.load_shader("/$$rp/shader/default_gui_shader.vert.glsl", cache_key)
def __init__(self, font="/$$rp/data/font/roboto-bold.ttf", pixel_size=16, align="left",
pos=Vec2(0), color=Vec3(1), parent=None):
""" Constructs a new text node, forwaring the parameters to the internal
panda3d implementation """
RPObject.__init__(self)
self._node = TextNodeImpl('FTN')
self._node.set_text("")
self._node.set_align(getattr(TextNodeImpl, "A_" + align))
self._node.set_text_color(color.x, color.y, color.z, 1)
if parent is None:
parent = Globals.base.aspect2d
self._nodepath = parent.attach_new_node(self._node)
self._nodepath.set_pos(pos.x, 0, pos.y)
font = RPLoader.load_font(font)
font.set_outline(Vec4(0, 0, 0, 0.78), 1.6, 0.37)
font.set_scale_factor(1.0)
font.set_texture_margin(int(pixel_size / 4.0 * 2.0))
font.set_bg(Vec4(0, 0, 0, 0))
self._node.set_font(font)
self.set_pixel_size(pixel_size)
def on_pipeline_created(self):
dirt_tex = RPLoader.load_texture(self.get_resource("lens_dirt.txo"))
self._bloom_stage.set_shader_input("LensDirtTex", dirt_tex)
def load_default_skybox(self):
skybox = RPLoader.load_model("/$$rp/data/builtin_models/skybox/skybox.bam")
return skybox
def _load_skydome(self):
""" Loads the skydome """
skydome = RPLoader.load_texture("/$$rp/data/builtin_models/skybox/skybox.txo")
skydome.set_wrap_u(SamplerState.WM_clamp)
skydome.set_wrap_v(SamplerState.WM_clamp)
self._pipeline.stage_mgr.inputs["DefaultSkydome"] = skydome
def reload_shaders(self):
""" Reloads the command shader """
shader = RPLoader.load_shader(
"/$$rp/shader/default_post_process.vert.glsl",
"/$$rp/shader/process_command_queue.frag.glsl")
self._command_target.shader = shader
def load_default_skybox(self):
skybox = RPLoader.load_model(
"/$$rp/data/builtin_models/skybox/skybox.bam")
return skybox
def on_pipeline_created(self):
dirt_tex = RPLoader.load_texture(self.get_resource("lens_dirt.txo.pz"))
self._bloom_stage.set_shader_input("LensDirtTex", dirt_tex)
def reload_shaders(self):
""" Reloads the command shader """
shader = RPLoader.load_shader(
"/$$rp/shader/default_post_process.vert.glsl",
"/$$rp/shader/process_command_queue.frag.glsl")
self._command_target.shader = shader
