def update(scn, openvr_frame_renderer):
if calibration_matrix is None:
load_calibration()
if recording:
update_recording(scn)
elif playing or playing_record_frame or do_calibration:
update_play(scn, openvr_frame_renderer)
if show_live_cam:
plus = gs.GetPlus()
size = plus.GetRendererAsync().GetCurrentOutputWindow().GetSize()
if openvr_frame_renderer is not None:
scn.GetSystem("Renderable").SetFrameRenderer(None)
plus.GetRendererAsync().SetViewport(
gs.fRect(0, 0, size.x * 0.5, size.y * 0.5))
plus.GetRendererAsync().SetClippingRect(
gs.fRect(0, 0, size.x * 0.5, size.y * 0.5))
plus.GetRendererAsync().Clear(gs.Color.Black)
scn.GetCurrentCamera().GetTransform().SetWorld(saved_cam_matrix)
scn.Update(gs.time(0))
scn.WaitUpdate()
scn.Commit()
scn.WaitCommit()
plus.GetRendererAsync().SetViewport(gs.fRect(0, 0, size.x, size.y))
plus.GetRendererAsync().SetClippingRect(gs.fRect(0, 0, size.x, size.y))
if openvr_frame_renderer is not None:
scn.GetSystem("Renderable").SetFrameRenderer(openvr_frame_renderer)
def affiche_texture_rendu_basique(cls,id_fbo=FBO_RENDU_1):
cls.rendu.SetRenderTarget(None)
window_size = cls.rendu.GetDefaultOutputWindow().GetSize()
cls.rendu.SetViewport(gs.fRect(0, 0, window_size.x, window_size.y)) # fit viewport to window dimensions
cls.rendu.Clear(gs.Color.Black) # red
cls.rendu.SetShader(Demo.pr_shader_filtres_basiques)
cls.rendu.SetShaderTexture("u_tex", cls.pr_textures[id_fbo])
#cls.rendu.SetShaderFloat("saturation", cls.pr_saturation_avec_seuil)
cls.rendu.SetShaderFloat("contraste", cls.pr_contraste)
cls.rendu.SetShaderFloat("seuil", cls.pr_seuil_contraste)
cls.rendu.SetShaderFloat("H", cls.pr_Hue)
cls.rendu.SetShaderFloat("S", cls.pr_Saturation)
cls.rendu.SetShaderFloat("V", cls.pr_Value)
cls.affiche_texture_rendu()
def affiche_rendu_shaders(cls):
window_size=Demo.rendu.GetDefaultOutputWindow().GetSize()
Demo.rendu.SetViewport(gs.fRect(0, 0, window_size.x, window_size.y)) # fit viewport to window dimensions
Demo.rendu.Clear(gs.Color(0.,0.,0.,0.))
Demo.rendu.EnableBlending(False)
Demo.rendu.SetShader(cls.shader_terrain)
Demo.rendu.SetShaderTexture("texture_terrain", cls.texture_terrain1)
Demo.rendu.SetShaderTexture("texture_terrain2", cls.texture_terrain2)
Demo.rendu.SetShaderTexture("texture_terrain3", cls.texture_terrain3)
Demo.rendu.SetShaderFloat("ratio_ecran",window_size.y/window_size.x)
Demo.rendu.SetShaderFloat("distanceFocale",Demo.calcul_distance_focale(cls.camera)) #cls.camera.GetCamera().GetZoomFactor()/2.)
cam=cls.camera.GetTransform()
camPos=cam.GetPosition()
Demo.rendu.SetShaderFloat3("obs_pos",camPos.x,camPos.y,camPos.z)
Demo.rendu.SetShaderMatrix3("obs_mat_normale",cam.GetWorld().GetRotationMatrix())
Demo.rendu.SetShaderFloat2("facteur_echelle_terrain",1./cls.facteur_echelle_terrain_l1.x,1./cls.facteur_echelle_terrain_l1.y)
Demo.rendu.SetShaderFloat2("facteur_echelle_terrain2",1./cls.facteur_echelle_terrain_l2.x,1./cls.facteur_echelle_terrain_l2.y)
Demo.rendu.SetShaderFloat2("facteur_echelle_terrain3",1./cls.facteur_echelle_terrain_l3.x,1./cls.facteur_echelle_terrain_l3.y)
Demo.rendu.SetShaderFloat("amplitude_terrain",cls.amplitude_l1)
Demo.rendu.SetShaderFloat("amplitude_terrain2",cls.amplitude_l2)
Demo.rendu.SetShaderFloat("amplitude_terrain3",cls.amplitude_l3)
Demo.rendu.SetShaderFloat("facteur_precision_distance",cls.facteur_precision_distance)
Demo.rendu.SetShaderFloat("altitude_eau",cls.altitude_eau)
Demo.rendu.SetShaderFloat("intensite_ambiante",cls.terrain_intensite_ambiante)
Demo.rendu.SetShaderFloat3("couleur_zenith",cls.couleur_zenith.r,cls.couleur_zenith.g,cls.couleur_zenith.b)
Demo.rendu.SetShaderFloat3("couleur_horizon",cls.couleur_horizon.r,cls.couleur_horizon.g,cls.couleur_horizon.b)
Demo.rendu.SetShaderFloat3("couleur_neige",cls.couleur_neige.r,cls.couleur_neige.g,cls.couleur_neige.b)
Demo.rendu.SetShaderFloat3("couleur_eau",cls.couleur_eau.r,cls.couleur_eau.g,cls.couleur_eau.b)
l_dir=cls.lumiere_soleil.GetTransform().GetWorld().GetRotationMatrix().GetZ()
Demo.drapeau_erreur=True
Demo.message_erreur={"x:"+str(l_dir.x),"y:"+str(l_dir.y),"z:"+str(l_dir.z)}
Demo.rendu.SetShaderFloat3("l1_direction",l_dir.x,l_dir.y,l_dir.z)
l_couleur=cls.lumiere_soleil.GetLight().GetDiffuseColor()
Demo.rendu.SetShaderFloat3("l1_couleur",l_couleur.r,l_couleur.g,l_couleur.b)
l_dir=cls.lumiere_ciel.GetTransform().GetWorld().GetRotationMatrix().GetZ()
Demo.rendu.SetShaderFloat3("l2_direction",l_dir.x,l_dir.y,l_dir.z)
l_couleur=cls.lumiere_ciel.GetLight().GetDiffuseColor()*cls.lumiere_ciel.GetLight().GetDiffuseIntensity()
Demo.rendu.SetShaderFloat3("l2_couleur",l_couleur.r,l_couleur.g,l_couleur.b)
Demo.rendu.SetShaderFloat2("zFrustum",cls.camera.GetCamera().GetZNear(),cls.camera.GetCamera().GetZFar())
Demo.affiche_texture_rendu()
pass
def blur(tgt_1, pict_1, tgt_2, pict_2):
plus.GetRendererAsync().SetRenderTarget(tgt_2)
plus.GetRendererAsync().SetViewport(
gs.fRect(0, 0, screen_size.x, screen_size.y))
plus.GetRendererAsync().Set2DMatrices()
plus.GetRendererAsync().EnableBlending(True)
plus.GetRendererAsync().SetShader(single_texture_shader)
plus.GetRenderSystemAsync().SetShaderEngineValues()
horizontal = 0
for i in range(5):
plus.GetRendererAsync().SetRenderTarget(tgt_2)
plus.GetRendererAsync().Clear(gs.Color(0, 0, 0, 0))
plus.GetRendererAsync().SetShaderTexture("u_tex", pict_1)
plus.GetRendererAsync().SetShaderValue("horizontal", horizontal)
plus.GetRenderSystemAsync().DrawTriangleUV(2, vtxs, uvs)
plus.GetRendererAsync().DrawFrame()
plus.GetRendererAsync().Sync()
tgt_1, tgt_2 = tgt_2, tgt_1
pict_1, pict_2 = pict_2, pict_1
horizontal = (horizontal + 1) % 2
return pict_1
# check all full all_checked = True for is_full in array_full_point: if not is_full: all_checked = False if all_checked: reducing = 5.0 next_symbol = True if start: render.text2d(3.0*size_pixel.x, size.y/7*6, "Finish the ritual to close\nthe demon's portal !", 6.5*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf") render.text2d(31.25*size_pixel.x, size.y/7*1.5, "Easy", 8.5*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf") render.text2d(31.25*size_pixel.x, size.y/7*1, "Hard", 8.5*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf") render.text2d(31.25*size_pixel.x, 10, "Exit", 8.5*size_pixel.x, gameboy_palette[2], font_path="Early GameBoy.ttf") if not input.mouse_button_was_down() and input.mouse_button_down(): easy_rect = gs.fRect(31.25*size_pixel.x, size.y/7*1.5, 31.25*size_pixel.x + 31.25*size_pixel.x, size.y/7*1.5 + 8.5*size_pixel.x) hard_rect = gs.fRect(31.25*size_pixel.x, size.y/7*1, 31.25*size_pixel.x + 31.25*size_pixel.x, size.y/7*1 + 8.5*size_pixel.x) exit_rect = gs.fRect(31.25*size_pixel.x, 10, 31.25*size_pixel.x + 31.25*size_pixel.x, 10 + 8.5*size_pixel.x) if easy_rect.Inside(input.get_mouse_pos()[0], input.get_mouse_pos()[1]): start = False reset = False reduce_speed = 15 increase_speed = 15 if hard_rect.Inside(input.get_mouse_pos()[0], input.get_mouse_pos()[1]): start = False reset = False reduce_speed = 10 increase_speed = 25 if exit_rect.Inside(input.get_mouse_pos()[0], input.get_mouse_pos()[1]): exit = True
def final():
render.clear()
# initialize graphic and audio systems
movie = gs.WebMMovie()
movie.Open("@data/sylvain_durif.webm")
video_format = movie.GetVideoData().GetFormat()
# create the frame textures and frame object
gpu = render.get_renderer()
y_tex = gpu.NewTexture()
gpu.CreateTexture(y_tex, video_format.width, video_format.height, gs.GpuTexture.R8, gs.GpuTexture.NoAA,
gs.GpuTexture.UsageDefault, False)
u_tex = gpu.NewTexture()
gpu.CreateTexture(u_tex, video_format.width // 2, video_format.height // 2, gs.GpuTexture.R8,
gs.GpuTexture.NoAA, gs.GpuTexture.UsageDefault, False)
v_tex = gpu.NewTexture()
gpu.CreateTexture(v_tex, video_format.width // 2, video_format.height // 2, gs.GpuTexture.R8,
gs.GpuTexture.NoAA, gs.GpuTexture.UsageDefault, False)
frame = gs.VideoFrame()
video_format.ClearFrame(frame)
video_timestamp = gs.time(0) # assume first frame time stamp is 0
# load the YV12 to RGB shader and setup drawing states
shader = gpu.LoadShader("@data/yv12.isl")
gpu.EnableDepthTest(False) # disable depth testing so that we don't even need to clear the z-buffer
# start streaming the movie audio data
channel = audio.get_mixer().StreamData(movie.GetAudioData())
# play until movie ends
while not movie.IsEOF():
render.clear()
# fit the while output window
screen_size = gpu.GetCurrentOutputWindow().GetSize()
gpu.SetViewport(gs.fRect(0, 0, screen_size.x, screen_size.y))
gpu.Set2DMatrices() # update the 2d matrix
# fetch the next video frame once audio gets past video
audio_timestamp = audio.get_mixer().GetChannelPosition(channel) # audio timestamp as reported by the mixer
if audio_timestamp >= video_timestamp:
movie.GetVideoData().GetFrame(frame)
video_timestamp = frame.GetTimestamp()
gpu.BlitTexture(y_tex, frame.GetPlaneData(gs.VideoFrame.Y), video_format.width, video_format.height)
gpu.BlitTexture(u_tex, frame.GetPlaneData(gs.VideoFrame.U), video_format.width // 2,
video_format.height // 2)
gpu.BlitTexture(v_tex, frame.GetPlaneData(gs.VideoFrame.V), video_format.width // 2,
video_format.height // 2)
# draw the current video frame to screen
vtxs = [gs.Vector3(0, 0, 0.5), gs.Vector3(0, screen_size.y, 0.5),
gs.Vector3(screen_size.x, screen_size.y, 0.5), gs.Vector3(0, 0, 0.5),
gs.Vector3(screen_size.x, screen_size.y, 0.5), gs.Vector3(screen_size.x, 0, 0.5)]
uvs = [gs.Vector2(0, 1), gs.Vector2(0, 0), gs.Vector2(1, 0), gs.Vector2(0, 1), gs.Vector2(1, 0),
gs.Vector2(1, 1)]
render_system = render.get_render_system()
gpu.SetShader(shader)
gs.SetShaderEngineValues(render_system)
gpu.SetShaderTexture("y_tex", y_tex)
gpu.SetShaderTexture("u_tex", u_tex)
gpu.SetShaderTexture("v_tex", v_tex)
render_system.DrawTriangleUV(2, vtxs, uvs)
render.flip()
while render.has_output_window() and not input.key_down(gs.InputDevice.KeyEscape):
# ---- Mise à jour timing:
Demo.horloge.Update()
Demo.temps = Demo.horloge.Get().to_sec()
Demo.delta_t = Demo.horloge.GetDelta().to_sec()
Demo.numero_frame+=1
#------ Premier rendu:
#Demo.systeme.SetOutputRenderTarget(Demo.pr_fbo_rendu)
Demo.rendu.SetRenderTarget(Demo.renvoie_fbo(Demo.FBO_RENDU_1))
#Demo.rendu.Clear(gs.Color(0,0,1,0),1)
window_size = Demo.rendu.GetDefaultOutputWindow().GetSize()
Demo.rendu.SetViewport(gs.fRect(0, 0, window_size.x, window_size.y))# fit viewport to texture dimensions
# ---- Gestion du signal du rendu précedent:
# Placé ici car il faut laissé au rendu précédent le temps de se dérouler normalement.
gestion_signal_scene(Demo.signal_scene)
# ---- Rendu de la scène:
Demo.Scene_actuelle.maj_cinetique()
Demo.signal_scene=Demo.Scene_actuelle.maj_physique() #Si il y a des réactions aux mouvements.
# ---- Mise à jour Caméra:
Demo.Scene_actuelle.maj_camera()
def affiche_texture_rendu_aura(cls,drapeau_rendu_shader=False):
window_size = cls.rendu.GetDefaultOutputWindow().GetSize()
cls.rendu.EnableBlending(False)
texture_scene_id=cls.FBO_RENDU_1
#------ Fusion de deux scènes si besoin:
if drapeau_rendu_shader:
cls.rendu.SetRenderTarget(cls.pr_fbos[cls.FBO_RENDU_3])
cls.rendu.SetViewport(gs.fRect(0, 0, window_size.x,window_size.y))
cls.rendu.Clear(gs.Color.Black) # red
cls.rendu.SetShader(Demo.pr_shader_fusion_2_textures_depth)
cls.rendu.SetShaderTexture("u_tex_scene1", cls.pr_textures[cls.FBO_RENDU_1])
cls.rendu.SetShaderTexture("u_tex_scene2", cls.pr_textures[cls.FBO_RENDU_2])
cls.rendu.SetShaderTexture("u_tex_scene1_depth", cls.pr_textures_depth[cls.FBO_RENDU_1])
cls.rendu.SetShaderTexture("u_tex_scene2_depth", cls.pr_textures_depth[cls.FBO_RENDU_2])
cls.affiche_texture_rendu()
texture_scene_id=cls.FBO_RENDU_3
#------ Contraste pour isoler les surfaces claires:
cls.rendu.SetRenderTarget(cls.pr_fbos[cls.FBO_LOW_1])
cls.rendu.SetViewport(gs.fRect(0, 0, cls.TAILLE_FBO_LO, cls.TAILLE_FBO_LO))
cls.rendu.Clear(gs.Color.Black) # red
cls.rendu.SetShader(Demo.pr_shader_filtres_basiques)
cls.rendu.SetShaderTexture("u_tex", cls.pr_textures[texture_scene_id])
cls.rendu.SetShaderFloat("contraste", cls.pr_aura_contraste)
cls.rendu.SetShaderFloat("seuil", cls.pr_aura_seuil_contraste)
cls.rendu.SetShaderFloat("H", cls.pr_aura_hue)
cls.rendu.SetShaderFloat("S", cls.pr_aura_saturation)
cls.rendu.SetShaderFloat("V", cls.pr_aura_value)
cls.affiche_texture_rendu()
#--------- Floutage X:
cls.rendu.SetRenderTarget(cls.pr_fbos[cls.FBO_LOW_2])
cls.rendu.SetShader(Demo.pr_shader_flou_x)
cls.rendu.SetShaderTexture("u_tex", cls.pr_textures[cls.FBO_LOW_1])
#cls.rendu.SetShaderFloat("saturation", cls.pr_saturation_avec_seuil)
cls.rendu.SetShaderInt("taille_flou", cls.pr_taille_aura)
cls.rendu.SetShaderFloat("saturation_flou", cls.pr_intensite_aura)
cls.rendu.SetShaderFloat("taille_texture", window_size.x)
cls.affiche_texture_rendu()
#--------- Floutage Y:
cls.rendu.SetRenderTarget(cls.pr_fbos[cls.FBO_LOW_1])
cls.rendu.SetShader(Demo.pr_shader_flou_y)
cls.rendu.SetShaderTexture("u_tex", cls.pr_textures[cls.FBO_LOW_2])
#cls.rendu.SetShaderFloat("saturation", cls.pr_saturation_avec_seuil)
cls.rendu.SetShaderInt("taille_flou", cls.pr_taille_aura)
cls.rendu.SetShaderFloat("saturation_flou", cls.pr_intensite_aura)
cls.rendu.SetShaderFloat("taille_texture", window_size.y)
cls.affiche_texture_rendu()
#--------- Superposition des textures et filtre final:
cls.rendu.SetRenderTarget(None)
cls.rendu.SetViewport(gs.fRect(0, 0, window_size.x, window_size.y)) # fit viewport to window dimensions
cls.rendu.Clear(gs.Color.Black)
cls.rendu.SetShader(Demo.pr_shader_2_textures_filtres)
cls.rendu.SetShaderTexture("u_tex1", cls.pr_textures[texture_scene_id])
cls.rendu.SetShaderTexture("u_tex2", cls.pr_textures[cls.FBO_LOW_1])
cls.rendu.SetShaderFloat("alpha_1", cls.pr_alpha_rendu)
cls.rendu.SetShaderFloat("alpha_2", cls.pr_alpha_aura)
cls.rendu.SetShaderFloat("contraste", cls.pr_Contraste)
cls.rendu.SetShaderFloat("seuil", cls.pr_Seuil_contraste)
cls.rendu.SetShaderFloat("H", cls.pr_Hue)
cls.rendu.SetShaderFloat("S", cls.pr_Saturation)
cls.rendu.SetShaderFloat("V", cls.pr_Value)
cls.rendu.EnableBlending(True)
cls.affiche_texture_rendu()
def affiche_rendu_shaders(cls):
window_size = Demo.rendu.GetDefaultOutputWindow().GetSize()
Demo.rendu.SetViewport(
gs.fRect(0, 0, window_size.x,
window_size.y)) # fit viewport to window dimensions
Demo.rendu.Clear(gs.Color(0., 0., 0., 0.))
Demo.rendu.EnableBlending(False)
Demo.rendu.SetShader(cls.shader_terrain)
Demo.rendu.SetShaderTexture("texture_terrain", cls.texture_terrain1)
Demo.rendu.SetShaderTexture("texture_terrain2", cls.texture_terrain2)
Demo.rendu.SetShaderTexture("texture_terrain3", cls.texture_terrain3)
Demo.rendu.SetShaderFloat("ratio_ecran", window_size.y / window_size.x)
Demo.rendu.SetShaderFloat(
"distanceFocale", Demo.calcul_distance_focale(
cls.camera)) #cls.camera.GetCamera().GetZoomFactor()/2.)
cam = cls.camera.GetTransform()
camPos = cam.GetPosition()
Demo.rendu.SetShaderFloat3("obs_pos", camPos.x, camPos.y, camPos.z)
Demo.rendu.SetShaderMatrix3("obs_mat_normale",
cam.GetWorld().GetRotationMatrix())
Demo.rendu.SetShaderFloat2("facteur_echelle_terrain",
1. / cls.facteur_echelle_terrain_l1.x,
1. / cls.facteur_echelle_terrain_l1.y)
Demo.rendu.SetShaderFloat2("facteur_echelle_terrain2",
1. / cls.facteur_echelle_terrain_l2.x,
1. / cls.facteur_echelle_terrain_l2.y)
Demo.rendu.SetShaderFloat2("facteur_echelle_terrain3",
1. / cls.facteur_echelle_terrain_l3.x,
1. / cls.facteur_echelle_terrain_l3.y)
Demo.rendu.SetShaderFloat("amplitude_terrain", cls.amplitude_l1)
Demo.rendu.SetShaderFloat("amplitude_terrain2", cls.amplitude_l2)
Demo.rendu.SetShaderFloat("amplitude_terrain3", cls.amplitude_l3)
Demo.rendu.SetShaderFloat("facteur_precision_distance",
cls.facteur_precision_distance)
Demo.rendu.SetShaderFloat("altitude_eau", cls.altitude_eau)
Demo.rendu.SetShaderFloat("intensite_ambiante",
cls.terrain_intensite_ambiante)
Demo.rendu.SetShaderFloat3("couleur_zenith", cls.couleur_zenith.r,
cls.couleur_zenith.g, cls.couleur_zenith.b)
Demo.rendu.SetShaderFloat3("couleur_horizon", cls.couleur_horizon.r,
cls.couleur_horizon.g,
cls.couleur_horizon.b)
Demo.rendu.SetShaderFloat3("couleur_neige", cls.couleur_neige.r,
cls.couleur_neige.g, cls.couleur_neige.b)
Demo.rendu.SetShaderFloat3("couleur_eau", cls.couleur_eau.r,
cls.couleur_eau.g, cls.couleur_eau.b)
l_dir = cls.lumiere_soleil.GetTransform().GetWorld().GetRotationMatrix(
).GetZ()
Demo.drapeau_erreur = True
Demo.message_erreur = {
"x:" + str(l_dir.x), "y:" + str(l_dir.y), "z:" + str(l_dir.z)
}
Demo.rendu.SetShaderFloat3("l1_direction", l_dir.x, l_dir.y, l_dir.z)
l_couleur = cls.lumiere_soleil.GetLight().GetDiffuseColor()
Demo.rendu.SetShaderFloat3("l1_couleur", l_couleur.r, l_couleur.g,
l_couleur.b)
l_dir = cls.lumiere_ciel.GetTransform().GetWorld().GetRotationMatrix(
).GetZ()
Demo.rendu.SetShaderFloat3("l2_direction", l_dir.x, l_dir.y, l_dir.z)
l_couleur = cls.lumiere_ciel.GetLight().GetDiffuseColor(
) * cls.lumiere_ciel.GetLight().GetDiffuseIntensity()
Demo.rendu.SetShaderFloat3("l2_couleur", l_couleur.r, l_couleur.g,
l_couleur.b)
Demo.rendu.SetShaderFloat2("zFrustum",
cls.camera.GetCamera().GetZNear(),
cls.camera.GetCamera().GetZFar())
Demo.affiche_texture_rendu()
pass
while render.has_output_window() and not input.key_down(
gs.InputDevice.KeyEscape):
# ---- Mise à jour timing:
Demo.horloge.Update()
Demo.temps = Demo.horloge.Get().to_sec()
Demo.delta_t = Demo.horloge.GetDelta().to_sec()
Demo.numero_frame += 1
#------ Premier rendu:
#Demo.systeme.SetOutputRenderTarget(Demo.pr_fbo_rendu)
Demo.rendu.SetRenderTarget(Demo.renvoie_fbo(Demo.FBO_RENDU_1))
#Demo.rendu.Clear(gs.Color(0,0,1,0),1)
window_size = Demo.rendu.GetDefaultOutputWindow().GetSize()
Demo.rendu.SetViewport(
gs.fRect(0, 0, window_size.x,
window_size.y)) # fit viewport to texture dimensions
# ---- Gestion du signal du rendu précedent:
# Placé ici car il faut laissé au rendu précédent le temps de se dérouler normalement.
gestion_signal_scene(Demo.signal_scene)
# ---- Rendu de la scène:
Demo.Scene_actuelle.maj_cinetique()
Demo.signal_scene = Demo.Scene_actuelle.maj_physique(
) #Si il y a des réactions aux mouvements.
# ---- Mise à jour Caméra:
Demo.Scene_actuelle.maj_camera()
def update(scn, gui, openvr_frame_renderer):
global render_tgt_a, render_tgt_b, render_tgt_scene, gpu_texture_a, gpu_texture_b, gpu_texture_scene, scn_glow, single_texture_shader, vtxs, uvs
if not scn.IsReady():
return
screen_size = plus.GetRendererAsync().GetCurrentOutputWindow().GetSize()
if render_tgt_a is None:
render_tgt_a, gpu_texture_a = create_scene_render_target(
screen_size.x, screen_size.y)
render_tgt_b, gpu_texture_b = create_scene_render_target(
screen_size.x, screen_size.y)
render_tgt_scene, gpu_texture_scene = create_scene_render_target(
screen_size.x, screen_size.y)
scn_glow = plus.NewScene(False, False)
plus.AddEnvironment(scn_glow,
gs.Color.Transparent) # clear color to transparent
scn_glow.SetCurrentCamera(
plus.AddCamera(scn_glow,
scn.GetCurrentCamera().GetTransform().GetWorld()))
# find all node with name group, insert in the scn_glow and remove from the other
for node in scn.GetNodes():
if "group" in node.GetName():
new_node = plus.AddGeometry(
scn_glow,
node.GetObject().GetGeometry().GetName(),
node.GetTransform().GetWorld())
new_node.SetName(node.GetName())
# remove from the old
scn.RemoveNode(node)
plus.UpdateScene(scn_glow, gs.time(0))
plus.UpdateScene(scn_glow, gs.time(0))
single_texture_shader = plus.GetRendererAsync().LoadShader(
"assets/blur_texture.isl")
vtxs = [
gs.Vector3(0, 0, 0.5),
gs.Vector3(0, screen_size.y, 0.5),
gs.Vector3(screen_size.x, screen_size.y, 0.5),
gs.Vector3(0, 0, 0.5),
gs.Vector3(screen_size.x, screen_size.y, 0.5),
gs.Vector3(screen_size.x, 0, 0.5)
]
uvs = [
gs.Vector2(0, 1),
gs.Vector2(0, 0),
gs.Vector2(1, 0),
gs.Vector2(0, 1),
gs.Vector2(1, 0),
gs.Vector2(1, 1)
]
# check if change groupe
change_groupe(scn, gui, openvr_frame_renderer)
# render the geo in the first render target
plus.GetRendererAsync().SetRenderTarget(render_tgt_a)
plus.GetRendererAsync().Clear(gs.Color(0, 0, 0, 0))
plus.GetRendererAsync().SetViewport(
gs.fRect(0, 0, screen_size.x, screen_size.y))
if scn_glow.GetCurrentCamera() is not None:
scn_glow.GetCurrentCamera().GetTransform().SetWorld(
scn.GetCurrentCamera().GetTransform().GetWorld())
plus.UpdateScene(scn_glow, gs.time(0))
# render the first picture into the main scene second picture
def blur(tgt_1, pict_1, tgt_2, pict_2):
plus.GetRendererAsync().SetRenderTarget(tgt_2)
plus.GetRendererAsync().SetViewport(
gs.fRect(0, 0, screen_size.x, screen_size.y))
plus.GetRendererAsync().Set2DMatrices()
plus.GetRendererAsync().EnableBlending(True)
plus.GetRendererAsync().SetShader(single_texture_shader)
plus.GetRenderSystemAsync().SetShaderEngineValues()
horizontal = 0
for i in range(5):
plus.GetRendererAsync().SetRenderTarget(tgt_2)
plus.GetRendererAsync().Clear(gs.Color(0, 0, 0, 0))
plus.GetRendererAsync().SetShaderTexture("u_tex", pict_1)
plus.GetRendererAsync().SetShaderValue("horizontal", horizontal)
plus.GetRenderSystemAsync().DrawTriangleUV(2, vtxs, uvs)
plus.GetRendererAsync().DrawFrame()
plus.GetRendererAsync().Sync()
tgt_1, tgt_2 = tgt_2, tgt_1
pict_1, pict_2 = pict_2, pict_1
horizontal = (horizontal + 1) % 2
return pict_1
if single_texture_shader is not None and single_texture_shader.IsReady():
gpu_texture_blur = gpu_texture_a #blur(render_tgt_a, gpu_texture_a, render_tgt_b, gpu_texture_b)
# render the final picture
plus.GetRendererAsync().SetRenderTarget(None)
plus.GetRendererAsync().SetViewport(
gs.fRect(0, 0, screen_size.x, screen_size.y))
# render the slow scene output
plus.Texture2D(0, 0, 1, gpu_texture_scene, gs.Color.White, False, True)
plus.SetBlend2D(gs.BlendAlpha)
plus.Texture2D(0, 0, 1, gpu_texture_blur, gs.Color.White, False, True)
plus.SetBlend2D(gs.BlendOpaque)
