def draw(self): width = render.get_renderer().GetCurrentOutputWindow().GetSize().x height = render.get_renderer().GetCurrentOutputWindow().GetSize().y center = gs.Vector2(width/2, height/2) for pos_sphere in self.sphere_array: render.geometry3d(pos_sphere.pos.x, 0, pos_sphere.pos.y, self.wall_1m) circle3d(pos_sphere.pos.x, pos_sphere.pos.y, pos_sphere.r)
def play_simulation(): while not input.key_press(gs.InputDevice.KeyEscape): clock.update() fps.update(clock.get_dt()) render.set_camera3d(fps.pos.x, fps.pos.y, fps.pos.z, fps.rot.x, fps.rot.y, fps.rot.z) render.clear() for perso in array_perso: perso.draw() perso.update(physic_world) array_perso[0].kohonen_behaviour.draw(render.get_renderer().GetCurrentOutputWindow().GetSize().x, render.get_renderer().GetCurrentOutputWindow().GetSize().y) physic_world.draw() # render text if input.key_down(gs.InputDevice.KeyL): render.text2d(10, 120, 'Frag in Mem: %d' % KohonenBehaviour.memory.GetNbFragment()) for action in range(perso_actions.nb_actions): render.text2d(10, 140 + 20*action, 'Frag for %s: %d, %d%%' % (perso_actions.get_current_action_name(action), KohonenBehaviour.memory.m_NbFragmentPerActionArray[action], KohonenBehaviour.memory.m_TabPercentFragmentPerAction[action]), 12, array_perso[0].kohonen_behaviour.color_array[action]) render.text2d(10, 50, str(perso.selected_action)+" "+perso_actions.get_current_action_name(perso.selected_action)) #draw it to the screen render.flip()
def fade_between_scene(): global state, fade_percent if globals.prev_scene_fade != globals.current_scene: globals.current_scene.exit() # transition to the new scene state = state_fade_in # launch the fade in if state == state_fade_in: fade_percent += fade_speed * globals.dt_sec if fade_percent > 1: fade_percent = 1 state = state_fade_out loop = asyncio.get_event_loop() loop.run_until_complete(globals.current_scene.setup()) loop.close() globals.prev_scene_fade = globals.current_scene #launch fade out with the new scene if state == state_fade_out: fade_percent -= fade_speed * globals.dt_sec if fade_percent < 0: fade_percent = 0 state = state_ready if fade_percent > 0: color = gs.Color(0, 0, 0, fade_percent) size = render.get_renderer().GetCurrentOutputWindow().GetSize() render.triangle2d(0, 0, size.x, size.y, size.x, 0, color, color, color) render.triangle2d(0, 0, 0, size.y, size.x, size.y, color, color, color)
def init(cls):
cls.rendu = render.get_renderer()
cls.clavier = input.get_keyboard()
cls.systeme = render.get_render_system()
cls.rendu2d = gs.SimpleGraphicEngine()
cls.rendu2d.SetDepthWrite(False)
cls.rendu2d.SetDepthTest(True)
cls.rendu2d.SetBlendMode(gs.BlendAlpha)
cls.rendu_scene=None #Initialisé à chaque activation de scène
cls.texture_ombre_sol=Demo.rendu.LoadTexture("textures/ombre_sol.png")
cls.texture_bruit_01=Demo.rendu.LoadTexture("textures/bruit_01.png")
if cls.texture_ombre_sol is None or cls.texture_bruit_01 is None:
cls.message_erreur="Impossible de charger les textures de base"
cls.drapeau_erreur=True
#Shaders par défaut:
cls.shader_billboards=cls.systeme.LoadSurfaceShader("shaders/sprite_alpha.isl",False)
cls.shader_constant_map=cls.systeme.LoadSurfaceShader("shaders/constant_map.isl",False)
cls.shader_constant=cls.systeme.LoadSurfaceShader("shaders/diffuse_constante.isl",False)
cls.shader_ocean_01=cls.systeme.LoadSurfaceShader("shaders/ocean.isl",False)
cls.shader_ocean_02=cls.systeme.LoadSurfaceShader("shaders/ocean_proche.isl",False)
cls.shader_transparent=cls.systeme.LoadSurfaceShader("shaders/diffuse_alpha.isl",False)
#Init le post-rendu:
cls.init_post_rendu()
#Init le gestionnaire sonore:
cls.audio = gs.ALMixer()
cls.audio.Open()
def draw(self): width = render.get_renderer().GetCurrentOutputWindow().GetSize().x height = render.get_renderer().GetCurrentOutputWindow().GetSize().y self.inputs.draw() angle_dir = acos(self.dir.Normalized().Dot(gs.Vector2(1, 0))) * (-1 if self.dir.y > 0 else 1) render.geometry3d(self.pos.x, 0, self.pos.y, self.geo, 0, angle_dir + 1.57, 0) circle3d(self.pos.x, self.pos.y, 0.5) half_width, half_height = width/2, height/2 if self.pos.x > half_width: self.pos.x = half_width elif self.pos.x < -half_width: self.pos.x = -half_width elif self.pos.y > half_height: self.pos.y = half_height elif self.pos.y < -half_height: self.pos.y = -half_height
def render_strings_array(strings = None, fade = 1.0, fonts_dict = {}):
sys = render.get_render_system()
render.get_renderer().EnableBlending(True)
render.get_renderer().EnableDepthTest(False)
for line in strings:
font_key = line[4] + "_" + str(line[5])
if not font_key in fonts_dict:
fonts_dict[font_key] = gs.RasterFont("@assets/" + line[4] + ".ttf", int(line[5] * zoom_size() / 3), 512)
rect = fonts_dict[font_key].GetTextRect(sys, line[0])
x = (demo_screen_size[0] - rect.GetWidth()) * 0.5
y = (amiga_screen_size[1] - line[1]) * zoom_size()
fonts_dict[font_key].Write(sys, line[0], gs.Vector3(x, y, 0.5), gs.Color.White * fade)
sys.DrawRasterFontBatch()
render.get_renderer().EnableBlending(False)
# underline ?
for line in strings:
if line[3] == 1:
font_key = line[4] + "_" + str(line[5])
rect = fonts_dict[font_key].GetTextRect(sys, line[0])
x = (demo_screen_size[0] - rect.GetWidth()) * 0.5
y = (amiga_screen_size[1] - line[1]) * zoom_size() - (line[5] * 0.2 * zoom_size() / 3)
render.line2d(x, y, x + rect.GetWidth(), y, gs.Color.White * fade * fade, gs.Color.White * fade * fade)
return fonts_dict
def render_strings_array(strings=None, fade=1.0, fonts_dict={}):
sys = render.get_render_system()
render.get_renderer().EnableBlending(True)
render.get_renderer().EnableDepthTest(False)
for line in strings:
font_key = line[4] + "_" + str(line[5])
if not font_key in fonts_dict:
fonts_dict[font_key] = gs.RasterFont(
"@assets/" + line[4] + ".ttf", int(line[5] * zoom_size() / 3),
512)
rect = fonts_dict[font_key].GetTextRect(sys, line[0])
x = (demo_screen_size[0] - rect.GetWidth()) * 0.5
y = (amiga_screen_size[1] - line[1]) * zoom_size()
fonts_dict[font_key].Write(sys, line[0], gs.Vector3(x, y, 0.5),
gs.Color.White * fade)
sys.DrawRasterFontBatch()
render.get_renderer().EnableBlending(False)
# underline ?
for line in strings:
if line[3] == 1:
font_key = line[4] + "_" + str(line[5])
rect = fonts_dict[font_key].GetTextRect(sys, line[0])
x = (demo_screen_size[0] - rect.GetWidth()) * 0.5
y = (amiga_screen_size[1] - line[1]) * zoom_size() - (
line[5] * 0.2 * zoom_size() / 3)
render.line2d(x, y, x + rect.GetWidth(), y,
gs.Color.White * fade * fade,
gs.Color.White * fade * fade)
return fonts_dict
def draw(): global screen_clock def fade_sin(fade): return (math.cos(fade * 3.0) + 1.0) * 0.5 size = render.get_renderer().GetCurrentOutputWindow().GetSize() x = size.x * 0.5 - 100.0 y = size.y * 0.5 - 210.0 font_size = 80 screen_clock += dt_sec render.text2d(x - size.x * 0.001, y - size.y * 0.001, "Press Enter", font_size, gs.Color(0,0,0, fade_sin(screen_clock) * 0.5), globals.font_garamond) render.text2d(x, y, "Press Enter", font_size, gs.Color(1,1,1, fade_sin(screen_clock)), globals.font_garamond) y -= 40 render.text2d(300, y - 20.0, "The MedieCross Project 2010-2015, made for TigSource.com.", 30, gs.Color.Black, globals.font_garamond) render.text2d(350, y - 50.0, "Code : Emmanuel Julien - Art : Francois Gutherz", 30, gs.Color.Black, globals.font_garamond) render.text2d(360, y - 80.0, "Animation : Ryan Hagen - Engine : Harfang3D", 30, gs.Color.Black, globals.font_garamond)
import random if getattr(sys, 'frozen', False): app_path = os.path.dirname(sys.executable) else: app_path = os.path.dirname(os.path.realpath(__file__)) gs.LoadPlugins(gs.get_default_plugins_path()) # gs.plus.create_workers() render.init(1024, 921, os.path.normcase(os.path.realpath(os.path.join(app_path, "pkg.core")))) # render.init(1920, 1200, os.path.normcase(os.path.realpath(os.path.join(app_path, "pkg.core"))), 1, gs.Window.Fullscreen) gs.MountFileDriver(gs.StdFileDriver()) # get the big resolution size = render.get_renderer().GetCurrentOutputWindow().GetSize() big_resolution = gs.Vector2(160, 144) big_resolution = gs.Vector2(1920, 1200) size_pixel = gs.Vector2(size.x / big_resolution.x, size.y / big_resolution.y) half_size_pixel = size_pixel * 0.5 gameboy_palette = [gs.Color(50/255, 60/255, 37/255), gs.Color(83/255, 101/255, 61/255), gs.Color(117/255, 141/255, 86/255), gs.Color(151/255, 174/255, 122/255) ]
print("Can't parse: %s" % (','.join(map(str, sys.exc_info()))))
sys.exit(1)
if getattr(sys, 'frozen', False):
app_path = os.path.dirname(sys.executable)
else:
app_path = os.path.dirname(os.path.realpath(__file__))
gs.LoadPlugins(gs.get_default_plugins_path())
# gs.plus.create_workers()
render.init(1024, 1024, os.path.normcase(os.path.realpath(os.path.join(app_path, "pkg.core"))))
gs.MountFileDriver(gs.StdFileDriver())
# get the big resolution
size = render.get_renderer().GetCurrentOutputWindow().GetSize()
big_resolution = gs.Vector2(160, 144)
# big_resolution = gs.Vector2(60, 44)
size_pixel = gs.Vector2(size.x / big_resolution.x, size.y / big_resolution.y)
half_size_pixel = size_pixel * 0.5
gameboy_palette = [gs.Color(50/255, 60/255, 37/255),
gs.Color(83/255, 101/255, 61/255),
gs.Color(117/255, 141/255, 86/255),
gs.Color(151/255, 174/255, 122/255)
]
def drange(start, stop, step):
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()
for spr_file in os.listdir("data/"):
if not spr_file.startswith("scaled_"):
render.init(512, 512, "../pkg.core")
spr_pic = gs.LoadPicture("@data/" + spr_file)
w, h = spr_pic.GetWidth(), spr_pic.GetHeight()
render.uninit()
render.init(w * scaled_copies, h, "../pkg.core")
capture_buffer = gs.Picture(w * scaled_copies, h, gs.Picture.RGBA8)
for i in range(2):
render.clear(gs.Color(1, 0, 1))
for i in range(scaled_copies):
sprite_scale_factor = RangeAdjust(float(i), 0.0,
float(scaled_copies), 1.0,
min_factor)
render.image2d(i * w + (w * (1.0 - sprite_scale_factor) * 0.5),
h * (1.0 - sprite_scale_factor) * 0.5,
sprite_scale_factor, "@data/" + spr_file)
# render.sprite2d(512 - 64, 512 - 64, 128, "@data/blink.jpg")
# render.blit2d(0, 0, 512, 512, 80, 80, 512 - 160, 512 - 160, "@data/owl.jpg")
render.flip()
render.get_renderer().CaptureFramebuffer(capture_buffer)
gs.SavePicture(capture_buffer, "@data/" + "scaled_" + spr_file, 'STB',
'format:png')
