def shader(self, value):
self._shader = value
if value is None:
self.filter_manager.cleanup()
self.filter_manager = None
if self.filter_quad:
self.filter_quad.removeNode()
# print('removed shader')
return None
shader = value
if hasattr(value, '_shader'):
shader = value._shader
if not self.filter_manager:
self.filter_manager = FilterManager(base.win, base.cam)
self.render_texture = PandaTexture()
self.depth_texture = PandaTexture()
self.normals_texture = PandaTexture()
self.filter_quad = self.filter_manager.renderSceneInto(
colortex=self.render_texture, depthtex=self.depth_texture)
# from panda3d.core import AuxBitplaneAttrib
# self.filter_quad = self.filter_manager.renderSceneInto(colortex=self.render_texture, depthtex=self.depth_texture, auxtex=self.normal_texture, auxbits=AuxBitplaneAttrib.ABOAuxNormal)
self.filter_quad.setShaderInput("tex", self.render_texture)
self.filter_quad.setShaderInput("dtex", self.depth_texture)
# self.filter_quad.setShaderInput("ntex", self.normals_texture)
self.filter_quad.setShader(shader)
if hasattr(value, 'default_input'):
for key, value in value.default_input.items():
self.set_shader_input(key, value)
print('set camera shader to:', shader)
def __init__(self):
self.filter_tex = {}
self.manager = FilterManager(base.win, base.cam)
self.filters = {}
self.window_x = float(base.win.getXSize())
self.window_y = float(base.win.getYSize())
def setup_shaders(self, render_node):
shader_dir = os.path.dirname(__file__)
# Do not force power-of-two textures
p3d.Texture.set_textures_power_2(p3d.ATS_none)
# PBR shader
pbrshader = p3d.Shader.load(
p3d.Shader.SL_GLSL,
vertex=os.path.join(shader_dir, 'simplepbr.vert'),
fragment=os.path.join(shader_dir, 'simplepbr.frag')
)
render_node.set_shader(pbrshader)
# Tonemapping
manager = FilterManager(base.win, base.cam)
tonemap_tex = p3d.Texture()
tonemap_tex.set_component_type(p3d.Texture.T_float)
tonemap_quad = manager.render_scene_into(colortex=tonemap_tex)
tonemap_shader = p3d.Shader.load(
p3d.Shader.SL_GLSL,
vertex=os.path.join(shader_dir, 'post.vert'),
fragment=os.path.join(shader_dir, 'tonemap.frag')
)
tonemap_quad.set_shader(tonemap_shader)
tonemap_quad.set_shader_input('tex', tonemap_tex)
def enable(self):
'''
Enables the filter. It is assumed that after this operation the rendering operation
has been altered such that the filter effects will be visible.
'''
if self.isEnabled():
return
shader = self.game.getResources().loadShader(self.shader)
if shader is not None:
self.postProcess = FilterManager(
self.game.getView().getWindow(),
self.game.getView().panoRenderer.getCamera())
self.postProcess.windowEvent(self.game.getView().getWindow(
)) # auto resize buffers when window resizes
tex = Texture()
self.screenQuad = self.postProcess.renderSceneInto(colortex=tex)
self.screenQuad.setShader(shader)
self.screenQuad.setShaderInput("tex", tex)
self._applyShaderInputs()
self.enabled = True
else:
self.log.error(
'failed to set screen filter BlackAndWhite because shader %s was not found'
% self.shader)
def shader(self, value):
if value is None:
if self.filter_quad:
self.filter_quad.removeNode()
return None
self._shader = value
shader = value
if hasattr(value, '_shader'):
shader = value._shader
if not self.filter_manager:
self.filter_manager = FilterManager(base.win, base.cam)
self.render_texture = PandaTexture()
self.depth_texture = PandaTexture()
self.filter_quad = self.filter_manager.renderSceneInto(
colortex=self.render_texture, depthtex=self.depth_texture)
self.filter_quad.setShaderInput("tex", self.render_texture)
self.filter_quad.setShaderInput("dtex", self.depth_texture)
self.filter_quad.setShader(shader)
if hasattr(value, 'default_input'):
for key, value in value.default_input.items():
self.set_shader_input(key, value)
print('set camera shader to:', shader)
def __init__(self, base):
# Load shader sources to avoid model path problems
for src_set in all_shader_sources:
for i, filename in enumerate(src_set):
with open(filename, 'r') as fin:
src_set[i] = fin.read()
base.render.set_shader_auto()
base.render.set_attrib(p3d.LightRampAttrib.make_identity())
pbr_shader = p3d.Shader.make(p3d.Shader.SL_GLSL, *material_shader_sources)
base.render.set_shader(pbr_shader)
manager = FilterManager(base.win, base.cam)
aa_tex = p3d.Texture()
self.post_tex = p3d.Texture()
self.post_tex.set_component_type(p3d.Texture.T_float)
aa_quad = manager.renderSceneInto(colortex=self.post_tex)
post_quad = manager.renderQuadInto(colortex=aa_tex)
aa_quad.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, *antialias_shader_sources))
aa_quad.set_shader_input('source', aa_tex)
aa_quad.set_shader_input('viewport', base.win.get_size())
post_quad.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, *post_shader_sources))
post_quad.set_shader_input('tex', self.post_tex)
def reset(self):
self.manager.cleanup()
self.filter_tex = {}
self.manager = FilterManager(base.win, base.cam)
self.filters = {}
self.window_x = float(base.win.getXSize())
self.window_y = float(base.win.getYSize())
def resetup_tonemap():
# Destroy previous buffers so we can re-create
self.manager.cleanup()
# Create a new FilterManager instance
self.manager = FilterManager(self.window, self.camera_node)
self._setup_tonemapping()
def set_up(self):
self.display_region = base.camNode.get_display_region(0)
win = self.display_region.get_window()
self.perspective_lens = PerspectiveLens()
self.perspective_lens = base.camLens # use panda3d's default for automatic aspect ratio on window resize
self.lens = self.perspective_lens
self.perspective_lens.set_aspect_ratio(
window.aspect_ratio) # call in window instead
# self.perspective_lens.set_focal_length(50)
self.perspective_lens_node = LensNode('perspective_lens_node',
self.perspective_lens)
self.lens_node = self.perspective_lens_node
self.orthographic_lens = OrthographicLens()
self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio,
self.fov)
self.orthographic_lens_node = LensNode('orthographic_lens_node',
self.orthographic_lens)
application.base.cam.node().set_lens(self.lens)
self.orthographic = False
self.fov = 40
self.clip_plane_near = 0.1
self.clip_plane_far = 10000
self.ui_display_region = win.make_display_region()
self.ui_display_region.set_sort(20)
self.ui_camera = NodePath(PandaCamera('ui_camera'))
self.ui_lens = OrthographicLens()
# moved set_film_size() to window module for correct aspect ratio after setting window size
self.ui_lens.set_near_far(-1000, 1000)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
self.ui_render = NodePath('ui_render')
self.ui_render.set_depth_test(0)
self.ui_render.set_depth_write(0)
self.ui_camera.reparent_to(self.ui_render)
self.ui_display_region.set_camera(self.ui_camera)
scene.ui_camera = self.ui_camera
self.ui = Entity(eternal=True,
name='ui',
parent=self.ui_camera,
scale=(self.ui_size * .5, self.ui_size * .5))
self.overlay = Entity(parent=self.ui,
model='quad',
scale_x=self.aspect_ratio,
color=color.clear,
eternal=True,
z=-99)
self.filter_manager = FilterManager(base.win, base.cam)
self.render_texture = PandaTexture()
self.filter_quad = None
def __init__(self):
if DConfig.GetBool('textures-power-2', 1):
# This is a workaround, if ^ is enabled, the game would only render in the bottom left corner of the window.
self.notify.warning(
"Cannot be initialized with texture-power-2 config enabled.")
return
"""
The FilterManager constructor requires you to provide a window which is rendering a scene,
and the camera which is used by that window to render the scene.
These are henceforth called the 'original window' and the 'original camera.'
At the very moment ShaderManager only supports postprocessing shaders, which may be the reason why 2d gui is wonky w/ shaders.
It seems that FilterManager is used for post processing shaders...?
"""
self.manager = FilterManager(base.win, base.cam)
# self.manager2d = None
self.manager2d = FilterManager(base.win, base.cam2d)
self.notify.info("Initialized ShaderManager")
def set_up(self, use_filters=True):
self.display_region = base.camNode.get_display_region(0)
win = self.display_region.get_window()
self.perspective_lens = PerspectiveLens()
self.lens = self.perspective_lens
self.perspective_lens.set_aspect_ratio(window.aspect_ratio)
self.perspective_lens.set_focal_length(50)
self.perspective_lens_node = LensNode('perspective_lens_node',
self.perspective_lens)
self.lens_node = self.perspective_lens_node
self.orthographic_lens = OrthographicLens()
self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio,
self.fov)
self.orthographic_lens_node = LensNode('orthographic_lens_node',
self.orthographic_lens)
application.base.cam.node().set_lens(self.lens)
self.orthographic = False
self.fov = 40
self.clip_plane_near = 0.0001
self.clip_plane_far = 70000000
self.ui_display_region = win.make_display_region()
self.ui_display_region.set_sort(20)
self.ui_camera = NodePath(PandaCamera('ui_camera'))
self.ui_lens = OrthographicLens()
self.ui_lens.set_film_size(self.ui_size * .5 * self.aspect_ratio,
self.ui_size * .5)
self.ui_lens.set_near_far(-1000, 70000)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
self.ui_render = NodePath('ui_render')
self.ui_render.set_depth_test(0)
self.ui_render.set_depth_write(0)
self.ui_camera.reparent_to(self.ui_render)
self.ui_display_region.set_camera(self.ui_camera)
scene.ui_camera = self.ui_camera
# ui_camera.hide()
# self.black_bars_display_region = win.make_display_region()
# self.black_bars_display_region.set_sort(-100)
self.ui = Entity(eternal=True,
name='ui',
parent=self.ui_camera,
scale=(self.ui_size * .5, self.ui_size * .5))
scene.ui = self.ui
if (use_filters):
self.filter_manager = FilterManager(base.win, base.cam)
self.render_texture = PandaTexture()
self.filter_quad = None
def setup_post_effect(self):
self.manager = FilterManager(base.win, base.cam)
tex = Texture()
dtex = Texture()
quad = self.manager.renderSceneInto(colortex=tex, depthtex=dtex)
quad.setShader(
Shader.load(Shader.SL_GLSL, "vertex.glsl", "fragment.glsl"))
quad.setShaderInput("tex", tex)
quad.setShaderInput("dtex", dtex)
def setup_post_effect(self):
self.manager = FilterManager(base.win, base.cam2d)
tex = Texture()
#tex = loader.load_texture("assets/noise.png")
self.quad = self.manager.renderSceneInto(colortex=tex)
self.quad.setShader(Shader.load(Shader.SL_GLSL, "crt.vert","crt.frag"))
self.quad.setShaderInput("iResolution", (base.win.getXSize(), base.win.getYSize()))
self.quad.setShaderInput("pattern", base.loader.load_texture("assets/crt.png"))
self.quad.get_texture().set_wrap_u(SamplerState.WM_clamp)
self.quad.get_texture().set_wrap_v(SamplerState.WM_clamp)
base.accept("window-event", self.on_window_event)
def reset(self):
self.manager.cleanup()
self.filter_tex={}
self.manager=FilterManager(base.win, base.cam)
self.filters={}
self.window_x=float(base.win.getXSize())
self.window_y=float(base.win.getYSize())
if cfg['glsl-blur'] or cfg['glsl-distortion'] or cfg['glsl-flare'] or cfg['glsl-glare'] or cfg['glsl-lut']:
self.setupFilters()
elif cfg['use-fxaa']:
self.setupFxaa()
def __init__(self):
ShowBase.__init__(self)
depth = Texture("depth")
depth.setWrapU(Texture.WMClamp)
depth.setWrapV(Texture.WMClamp)
self.fmgr = FilterManager(self.win, self.cam)
depthQuad = self.fmgr.renderQuadInto(depthtex=depth)
#depthQuad.hide()
smiley = loader.loadModel("models/smiley.egg.pz")
smiley.reparentTo(render)
img = OnscreenImage(image=depth, scale=0.3, pos=(0, 0, -0.7))
def check_and_create_rendering_buffers(showbase):
if not settings.render_scene_to_buffer:
return
if not settings.buffer_texture:
print("Render to buffer not supported")
return
print("Render scene to buffer")
buffer_multisamples = 0
if settings.render_scene_to_buffer and not settings.disable_multisampling and settings.use_multisampling and settings.multisamples > 0:
buffer_multisamples = settings.multisamples
manager = FilterManager(showbase.win, showbase.cam)
color_buffer = Texture()
if settings.use_inverse_z:
render.set_attrib(DepthTestAttrib.make(DepthTestAttrib.M_greater))
depth_buffer = Texture()
showbase.win.set_clear_depth(0)
float_depth = True
depth_bits = 24
else:
depth_buffer = None
float_depth = False
depth_bits = 1
if settings.render_scene_to_float:
if settings.floating_point_buffer:
rgba_bits = (32, 32, 32, 32)
float_colors = True
else:
print(
"Floating point buffer not available, sRBG conversion will show artifacts"
)
rgba_bits = (1, 1, 1, 1)
float_colors = False
else:
rgba_bits = (1, 1, 1, 1)
float_colors = False
textures = {'color': color_buffer, 'depth': depth_buffer}
fbprops = FrameBufferProperties()
fbprops.setFloatColor(float_colors)
fbprops.setRgbaBits(*rgba_bits)
fbprops.setSrgbColor(settings.srgb_buffer)
fbprops.setDepthBits(depth_bits)
fbprops.setFloatDepth(float_depth)
fbprops.setMultisamples(buffer_multisamples)
final_quad = manager.render_scene_into(textures=textures, fbprops=fbprops)
final_quad_shader = PostProcessShader(
gamma_correction=settings.software_srgb,
hdr=settings.use_hdr).create_shader()
final_quad.set_shader(final_quad_shader)
final_quad.set_shader_input("color_buffer", color_buffer)
final_quad.set_shader_input("exposure", 2)
def __init__(self, base):
self.base = base
self.base.render.set_shader_auto()
p3d.Texture.setTexturesPower2(p3d.ATS_none)
manager = FilterManager(base.win, base.cam)
self.post_tex = p3d.Texture()
post_quad = manager.renderSceneInto(colortex=self.post_tex)
post_quad.set_shader(
p3d.Shader.make(p3d.Shader.SL_GLSL, _SRGB_VERT, _SRGB_FRAG))
post_quad.set_shader_input('tex', self.post_tex)
def __init__(self):
ShowBase.__init__(self)
manager = FilterManager(base.win, base.cam)
tex = Texture()
quad = manager.renderSceneInto(colortex=tex)
quad.setShader(Shader.load("myfilter.sha"))
quad.setShaderInput("tex", tex)
# Disable the camera trackball controls.
self.disableMouse()
# Load the environment model.
self.environ = self.loader.loadModel("models/environment")
# Reparent the model to render.
self.environ.reparentTo(self.render)
# Apply scale and position transforms on the model.
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, 0)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
# Loop its animation.
self.pandaActor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
pandaPosInterval1 = self.pandaActor.posInterval(13,
Point3(0, -10, 0),
startPos=Point3(0, 10, 0))
pandaPosInterval2 = self.pandaActor.posInterval(13,
Point3(0, 10, 0),
startPos=Point3(0, -10, 0))
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
def __init__(self):
self.filter_tex={}
self.manager=FilterManager(base.win, base.cam)
self.filters={}
self.window_x=float(base.win.getXSize())
self.window_y=float(base.win.getYSize())
render.setShaderInput('screen_size',Vec2(self.window_x,self.window_y))
log.debug('Filters: FilterManager started at '+str(base.win.getXSize())+'x'+str(base.win.getYSize()))
if cfg['use-filters']:
self.setupFilters()
elif cfg['use-fxaa']:
self.setupFxaa()
def __init__(self, base):
import panda3d.core as p3d
from direct.filter.FilterManager import FilterManager
self.base = base
self.base.render.set_shader_auto()
manager = FilterManager(base.win, base.cam)
self.post_tex = p3d.Texture()
post_quad = manager.renderSceneInto(colortex=self.post_tex)
post_quad.set_shader(
p3d.Shader.make(p3d.Shader.SL_GLSL, _srgb_vert, _srgb_frag))
post_quad.set_shader_input('tex', self.post_tex)
def __init__(self,
*,
render_node=None,
window=None,
camera_node=None,
msaa_samples=4,
max_lights=8,
use_normal_maps=False,
use_emission_maps=False,
exposure=1.0,
enable_shadows=False,
enable_fog=False,
use_occlusion_maps=False):
if render_node is None:
render_node = base.render
if window is None:
window = base.win
if camera_node is None:
camera_node = base.cam
self._shader_ready = False
self.render_node = render_node
self.window = window
self.camera_node = camera_node
self.max_lights = max_lights
self.use_normal_maps = use_normal_maps
self.use_emission_maps = use_emission_maps
self.enable_shadows = enable_shadows
self.enable_fog = enable_fog
self.exposure = exposure
self.msaa_samples = msaa_samples
self.use_occlusion_maps = use_occlusion_maps
# Create a FilterManager instance
self.manager = FilterManager(window, camera_node)
# Do not force power-of-two textures
p3d.Texture.set_textures_power_2(p3d.ATS_none)
# Make sure we have AA for if/when MSAA is enabled
self.render_node.set_antialias(p3d.AntialiasAttrib.M_auto)
# PBR Shader
self._recompile_pbr()
# Tonemapping
self._setup_tonemapping()
self._shader_ready = True
def __init__(self):
ShowBase.__init__(self)
self.render.setAntialias(AntialiasAttrib.MMultisample, 1)
model = self.loader.loadModel("models/panda")
model.reparent_to(self.render)
self.cam.set_pos(50, 50, 0)
self.cam.look_at(model)
self._manager = FilterManager(self.win, self.cam)
tex = Texture()
self.quad = self._manager.renderSceneInto(colortex=tex)
self.quad.setShader(Shader.load("./mono.sha"))
self.quad.setShaderInput("tex", tex)
def __init__(self, base):
base.render.set_shader_auto()
base.render.set_attrib(p3d.LightRampAttrib.make_identity())
pbr_shader = p3d.Shader.make(p3d.Shader.SL_GLSL, pbr_vert, pbr_frag)
base.render.set_shader(pbr_shader)
manager = FilterManager(base.win, base.cam)
tex = p3d.Texture()
quad = manager.renderSceneInto(colortex=tex)
quad.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, hdr_vert,
hdr_frag))
quad.set_shader_input('tex', tex)
self.base = base
def __init__(self):
self.manager = FilterManager(base.win, base.cam)
# Gonna use a Tuple for now
# This list should be stored somewhere else ultimately, probably like in a globals file
# [Friendly LUT Name, LUT Filepath]
self.LUTList = (
["Default", "phase_3/luts/def_lut.png"],
["LSD", "phase_3/luts/lsd_lut.png"],
["Sunset", "phase_3/luts/sunset_lut.png"],
["Natural Pop", "phase_3/luts/pop_lut.png"],
["Red+Black", "phase_3/luts/2_lut.png"]
)
self.vertexShader = "phase_3/shaders/lut-vert.glsl"
self.fragmentShader = "phase_3/shaders/lut-frag.glsl"
self.setupLUT(self.LUTList[0][1])
def setup_post_fx(self):
self.filter_mgr = FilterManager(base.win, base.cam)
col_tex = Texture()
final_tex = Texture()
final_quad = self.filter_mgr.renderSceneInto(colortex=col_tex)
inter_quad = self.filter_mgr.renderQuadInto(colortex=final_tex)
with open('yyagl/assets/shaders/filter.vert') as f:
vert = f.read()
with open('yyagl/assets/shaders/filter.frag') as f:
frag = f.read()
inter_quad.setShader(Shader.make(Shader.SLGLSL, vert, frag))
inter_quad.setShaderInput('in_tex', col_tex)
with open('yyagl/assets/shaders/pass.frag') as f:
frag = f.read()
final_quad.setShader(Shader.make(Shader.SLGLSL, vert, frag))
final_quad.set_shader_input('gamma', self.gamma)
final_quad.setShaderInput('in_tex', final_tex)
def __init__(self):
ShowBase.__init__(self)
pman.shim.init(self)
basic = core.Filename.expand_from(
'$MAIN_DIR/assets/textures/basic_1.exr')
basic = self.loader.load_texture(basic)
pipeline = simplematcap.init(basic,
render_node=self.render,
light_dir=core.Vec3(-1, -1,
0.5).normalized())
fog = core.Fog("Fog Name")
fog.set_color(0, 0, 0)
fog.set_exp_density(0.04)
self.render.set_fog(fog)
self.disable_mouse()
self.input = Input()
self.accept('escape', sys.exit)
self.accept('f1', self.toggle_wireframe)
self.world = World(pipeline)
self.set_background_color(util.srgb_color(0x000000))
self.manager = FilterManager(self.win, self.cam)
tex = core.Texture()
depth = core.Texture()
quad = self.manager.render_scene_into(colortex=tex, depthtex=depth)
post_vert_str = load_shader_str('post.vert')
post_frag_str = load_shader_str('post.frag')
postshader = core.Shader.make(
core.Shader.SL_GLSL,
vertex=post_vert_str,
fragment=post_frag_str,
)
quad.set_shader(postshader)
quad.set_shader_input('tex', tex)
quad.set_shader_input('blur', 2.5)
quad.set_shader_input('depth', depth)
def setup_filters(self):
fbprops = core.FrameBufferProperties()
if self.quality >= 3:
fbprops.multisamples = 16
self.filters = FilterManager(base.win, base.cam)
self.scene_tex = core.Texture()
self.scene_tex.set_wrap_u(core.Texture.WM_clamp)
self.scene_tex.set_wrap_v(core.Texture.WM_clamp)
self.quad = self.filters.render_scene_into(colortex=self.scene_tex, fbprops=fbprops)
if not self.quad and fbprops.multisamples:
# Try without multisampling.
fbprops.multisamples = None
self.quad = self.filters.render_scene_into(colortex=self.scene_tex)
if not self.quad:
return
if fbprops.multisamples:
self.render.set_antialias(core.AntialiasAttrib.M_multisample)
self.quad.clear_color()
prev_tex = self.scene_tex
if self.quality >= 3:
intermediate_tex = core.Texture()
intermediate_tex.set_minfilter(core.Texture.FT_linear)
intermediate_tex.set_magfilter(core.Texture.FT_linear)
intermediate_tex.set_wrap_u(core.Texture.WM_clamp)
intermediate_tex.set_wrap_v(core.Texture.WM_clamp)
intermediate_quad = self.filters.render_quad_into("blur-x", colortex=intermediate_tex)
intermediate_quad.set_shader_input("image", prev_tex)
intermediate_quad.set_shader_input("direction", (2, 0))
intermediate_quad.set_shader_input("scale", self.blur_scale)
intermediate_quad.set_shader(self.blur_shader)
prev_tex = intermediate_tex
intermediate_tex = core.Texture()
intermediate_tex.set_minfilter(core.Texture.FT_linear)
intermediate_tex.set_magfilter(core.Texture.FT_linear)
intermediate_tex.set_wrap_u(core.Texture.WM_clamp)
intermediate_tex.set_wrap_v(core.Texture.WM_clamp)
intermediate_quad = self.filters.render_quad_into("blur-y", colortex=intermediate_tex)
intermediate_quad.set_shader_input("image", prev_tex)
intermediate_quad.set_shader_input("direction", (0, 2))
intermediate_quad.set_shader_input("scale", self.blur_scale)
intermediate_quad.set_shader(self.blur_shader)
prev_tex = intermediate_tex
intermediate_tex = core.Texture()
intermediate_tex.set_minfilter(core.Texture.FT_linear)
intermediate_tex.set_magfilter(core.Texture.FT_linear)
intermediate_tex.set_wrap_u(core.Texture.WM_clamp)
intermediate_tex.set_wrap_v(core.Texture.WM_clamp)
intermediate_quad = self.filters.render_quad_into("blur-y", colortex=intermediate_tex)
intermediate_quad.set_shader_input("image", prev_tex)
intermediate_quad.set_shader_input("direction", (0, 4))
intermediate_quad.set_shader_input("scale", self.blur_scale)
intermediate_quad.set_shader(self.blur_shader)
prev_tex = intermediate_tex
self.blurred_tex = prev_tex
def init(*,
render_node=None,
window=None,
camera_node=None,
msaa_samples=4,
max_lights=8,
use_normal_maps=False):
'''Initialize the PBR render pipeline
:param render_node: The node to attach the shader too, defaults to `base.render` if `None`
:type render_node: `panda3d.core.NodePath`
:param window: The window to attach the framebuffer too, defaults to `base.win` if `None`
:type window: `panda3d.core.GraphicsOutput
:param camera_node: The NodePath of the camera to use when rendering the scene, defaults to `base.cam` if `None`
:type camera_node: `panda3d.core.NodePath
:param msaa_samples: The number of samples to use for multisample anti-aliasing, defaults to 4
:type msaa_samples: int
:param max_lights: The maximum number of lights to render, defaults to 8
:type max_lights: int
:param use_normal_maps: Use normal maps, defaults to `False` (NOTE: Requires models with appropriate tangents)
:type use_normal_maps: bool
'''
if render_node is None:
render_node = base.render
if window is None:
window = base.win
if camera_node is None:
camera_node = base.cam
# Do not force power-of-two textures
p3d.Texture.set_textures_power_2(p3d.ATS_none)
# PBR shader
pbr_defines = {
'MAX_LIGHTS': max_lights,
}
if use_normal_maps:
pbr_defines['USE_NORMAL_MAP'] = ''
pbr_vert_str = _load_shader_str('simplepbr.vert', pbr_defines)
pbr_frag_str = _load_shader_str('simplepbr.frag', pbr_defines)
pbrshader = p3d.Shader.make(
p3d.Shader.SL_GLSL,
vertex=pbr_vert_str,
fragment=pbr_frag_str,
)
render_node.set_shader(pbrshader)
# Tonemapping
manager = FilterManager(window, camera_node)
fbprops = p3d.FrameBufferProperties()
fbprops.float_color = True
fbprops.set_rgba_bits(16, 16, 16, 16)
fbprops.set_depth_bits(24)
fbprops.set_multisamples(msaa_samples)
scene_tex = p3d.Texture()
scene_tex.set_format(p3d.Texture.F_rgba16)
scene_tex.set_component_type(p3d.Texture.T_float)
tonemap_quad = manager.render_scene_into(colortex=scene_tex,
fbprops=fbprops)
post_vert_str = _load_shader_str('post.vert')
post_frag_str = _load_shader_str('tonemap.frag')
tonemap_shader = p3d.Shader.make(
p3d.Shader.SL_GLSL,
vertex=post_vert_str,
fragment=post_frag_str,
)
tonemap_quad.set_shader(tonemap_shader)
tonemap_quad.set_shader_input('tex', scene_tex)
def init(*,
render_node=None,
window=None,
camera_node=None,
msaa_samples=4,
max_lights=8):
'''Initialize the PBR render pipeline
:param render_node: The node to attach the shader too, defaults to `base.render` if `None`
:type render_node: `panda3d.core.NodePath`
:param window: The window to attach the framebuffer too, defaults to `base.win` if `None`
:type window: `panda3d.core.GraphicsOutput
:param camera_node: The NodePath of the camera to use when rendering the scene, defaults to `base.cam` if `None`
:type camera_node: `panda3d.core.NodePath
'''
if render_node is None:
render_node = base.render
if window is None:
window = base.win
if camera_node is None:
camera_node = base.cam
# Do not force power-of-two textures
p3d.Texture.set_textures_power_2(p3d.ATS_none)
# PBR shader
pbr_vert_str = _load_shader_str('simplepbr.vert')
pbr_frag_str = _load_shader_str('simplepbr.frag', {
'MAX_LIGHTS': max_lights,
})
pbrshader = p3d.Shader.make(
p3d.Shader.SL_GLSL,
vertex=pbr_vert_str,
fragment=pbr_frag_str,
)
render_node.set_shader(pbrshader)
# Tonemapping
manager = FilterManager(window, camera_node)
fbprops = p3d.FrameBufferProperties()
fbprops.float_color = True
fbprops.set_rgba_bits(16, 16, 16, 16)
fbprops.set_depth_bits(24)
fbprops.set_multisamples(msaa_samples)
scene_tex = p3d.Texture()
scene_tex.set_format(p3d.Texture.F_rgba16)
scene_tex.set_component_type(p3d.Texture.T_float)
tonemap_quad = manager.render_scene_into(colortex=scene_tex,
fbprops=fbprops)
post_vert_str = _load_shader_str('post.vert')
post_frag_str = _load_shader_str('tonemap.frag')
tonemap_shader = p3d.Shader.make(
p3d.Shader.SL_GLSL,
vertex=post_vert_str,
fragment=post_frag_str,
)
tonemap_quad.set_shader(tonemap_shader)
tonemap_quad.set_shader_input('tex', scene_tex)
def __init__(self, loadscreen, root):
self.loadscreen=loadscreen
#base.openMainWindow()
if not config_safemode.getValue():
render.setShaderAuto()
base.disableMouse()
#base.setBackgroundColor(0, 0, 0)
if not config_safemode.getValue():
if config_aa.getValue()>0:
render.setAntialias(AntialiasAttrib.MMultisample)
base.camLens.setNearFar(3, 40)
self.common={}
self.common['root']=root
self.common['safemode']=config_safemode.getValue()
#print self.common['safemode']
#keys
self.common['keymap']={}
self.common['keymap']['key_menuitems']=config_menuitems.getValue()
self.common['keymap']['key_useitem']=config_useitem.getValue()
self.common['keymap']['key_nextitem']=config_nextitem.getValue()
self.common['keymap']['key_forward']=config_forward.getValue().split('|')
self.common['keymap']['key_back']=config_back.getValue().split('|')
self.common['keymap']['key_left']=config_left.getValue().split('|')
self.common['keymap']['key_right']=config_right.getValue().split('|')
self.common['keymap']['key_cam_left']=config_camera_left.getValue().split('|')
self.common['keymap']['key_cam_right']=config_camera_right.getValue().split('|')
self.common['keymap']['key_action1']=config_action1.getValue().split('|')
self.common['keymap']['key_action2']=config_action2.getValue().split('|')
self.common['keymap']['key_zoomin']=config_zoomin.getValue().split('|')
self.common['keymap']['key_zoomout']=config_zoomout.getValue().split('|')
self.common['extra_ambient']=True
self.common['path']=path
self.common['max_level']=0
self.common["key_icon"]=DirectFrame(frameSize=(-64, 0, 0, 64),
frameColor=(1, 1, 1, 1),
frameTexture="icon/icon_key2.png",
parent=pixel2d)
self.common["key_icon"].setPos(64,0,-64)
self.common["key_icon"].setTransparency(TransparencyAttrib.MDual)
self.common["key_icon"].hide()
if config_bloom.getValue():
self.common['extra_ambient']=False
if config_safemode.getValue():
self.common['extra_ambient']=True
#print "extra ambient:", self.common['extra_ambient']
#audio 3d
self.common['audio3d']=Audio3DManager.Audio3DManager(base.sfxManagerList[0], base.camera)
self.common['audio3d'].setListenerVelocityAuto()
self.common['audio3d'].setDropOffFactor(0.2)
self.common['soundPool']=SoundPool(self.common)
base.sfxManagerList[0].setVolume(config_sfx.getValue()*0.01)
self.common['click']=base.loader.loadSfx("sfx/click_stereo.ogg")
self.common['click2']=base.loader.loadSfx("sfx/pen-click-1.wav")
#base.cTrav = CollisionTraverser()
self.common['monsterList']=[]
self.common['spawner']=Spawner(self.common)
self.common['levelLoader']=LevelLoader(self.common)
#self.common['PC']=PC(self.common)
#self.common['PC'].node.setPos(-12, 0, 0)
#spawner
#self.spawner=Spawner(self.common, monster_limit=5, tick=9.13)
#music
base.musicManager.setVolume(config_music.getValue()*0.01)
self.common['musicVolume']=config_music.getValue()
self.common['soundVolume']=config_sfx.getValue()
#self.music = [
# base.loadMusic("sfx/LuridDeliusion.ogg"),
# base.loadMusic("sfx/DefyingCommodus.ogg"),
# base.loadMusic("sfx/DarkDescent.ogg")
#base.loadMusic("sfx/DarkAmulet.ogg"),
#base.loadMusic("sfx/WastelandShowdown.ogg"),
#base.loadMusic("sfx/HeroicDemise.ogg")
# ]
#self.musicSequence=Sequence()
#for music in self.music:
# self.musicSequence.append(SoundInterval(music))
#self.musicSequence.loop()
#Monster(data.monsters[2],self.common, self.testPC, (12, -4, 0))
#self.flask=Interactive(self.common, "flask", (-12, 4, 0), 0.15, "vfx/icon_flask.png", "heal")
#self.health=Actor("models/health", {"anim":"models/health_anim"})
#self.health.loop("anim")
#self.health.reparentTo(render)
#self.health.setPos(-12, 4, 0)
#self.health.setScale(0.2)
#self.health.setLightOff()
self.common['traverser']=CollisionTraverser("playerTrav")
self.common['traverser'].setRespectPrevTransform(True)
self.common['queue'] = CollisionHandlerQueue()
self.common['CharGen']=CharGen(self.common)
base.openMainWindow(props = wp)
#bloom
if not config_safemode.getValue():
if config_bloom.getValue():
self.bloomBuffer=base.win.makeTextureBuffer("bloom", buff_size.getValue(), buff_size.getValue())
self.bloomBuffer.setSort(-3)
self.bloomBuffer.setClearColor(Vec4(0,0,0,1))
self.bloomCamera=base.makeCamera(self.bloomBuffer, lens=base.cam.node().getLens())
glowShader=loader.loadShader("shaders/glowShader.sha")
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(glowShader)
self.bloomCamera.node().setInitialState(tempnode.getState())
self.blurBuffer=self.makeFilterBuffer(self.bloomBuffer, "Blur X", -2, "shaders/blur.sha")
self.finalcard = self.blurBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
#shadow buffer
self.shadowTexture=Texture()
self.shadowTexture.setWrapU(Texture.WMBorderColor)
self.shadowTexture.setWrapV(Texture.WMBorderColor)
self.shadowTexture.setBorderColor(Vec4(1,1,1,1))
self.shadowBuffer = base.win.makeTextureBuffer("Shadow Buffer",buff_size.getValue(), buff_size.getValue(), self.shadowTexture)
self.shadowBuffer.setClearColor((1,1,1,1))
self.shadowCamera = base.makeCamera(self.shadowBuffer)
self.shadowNode = render.attachNewNode('shadowNode')
self.shadowNode.setP(-90)
#self.shadowNode.setZ(18)
self.shadowCamera.reparentTo(self.shadowNode)
#self.shadowCamera.node().showFrustum()
self.shadow_lens = PerspectiveLens()
self.shadow_lens.setFov(160)
self.shadow_lens.setNearFar(0.01,4)
self.shadowCamera.node().setLens(self.shadow_lens)
self.shadowCamera.node().setCameraMask(BitMask32.bit(1))
self.initial = NodePath('initial')
#self.initial.setTextureOff(2)
#self.initial.setMaterialOff(2)
self.initial.setLightOff(2)
self.initial.setColor(0,0,0,1)
self.shadowCamera.node().setInitialState(self.initial.getState())
shadow_manager = FilterManager(self.shadowBuffer, self.shadowCamera)
sh_tex1 = Texture()
quad = shadow_manager.renderSceneInto(colortex=sh_tex1)
quad.setShader(Shader.load("shaders/shadow.sha"))
quad.setShaderInput("tex1", sh_tex1)
self.shadow_ts=TextureStage('shadow')
self.common['shadowNode']=self.shadowNode
self.common['shadow_ts']=self.shadow_ts
self.common['shadowTexture']=self.shadowTexture
self.common['shadowCamera']= self.shadowCamera
taskMgr.add(self.hideLoadscreen, 'hideLoadscreenTask')
self.accept("x", self.screenshot)
