def __init__(self, name, plus, scene, node_file_name, num_particles, start_scale, end_scale, stream_angle,color_label="teint"): self.name = name self.color_label=color_label self.particles_cnt = 0 self.particles_cnt_f = 0 self.num_particles = num_particles self.flow = 8 self.particles_delay = 3 self.particles = [] self.create_particles(plus, scene, node_file_name) self.start_speed_range = hg.Vector2(800, 1200) self.delay_range = hg.Vector2(1, 2) self.start_scale = start_scale self.end_scale = end_scale self.scale_range = hg.Vector2(1,2) self.stream_angle = stream_angle self.colors = [hg.Color(1, 1, 1, 1), hg.Color(1, 1, 1, 0)] self.start_offset = 0 self.rot_range_x = hg.Vector2(0, 0) self.rot_range_y = hg.Vector2(0, 0) self.rot_range_z = hg.Vector2(0, 0) self.gravity=hg.Vector3(0,-9.8,0) self.linear_damping = 1 self.loop=True self.end=False #True when loop=True and all particles are dead self.num_new=0 self.reset()
def init_lights(plus):
# Main light:
Main.ligth_sun = plus.AddLight(Main.scene, hg.Matrix4.RotationMatrix(hg.Vector3(radians(25), radians(-45), 0)),
hg.LightModelLinear)
Main.ligth_sun.SetName("Sun")
Main.ligth_sun.GetLight().SetDiffuseColor(hg.Color(255. / 255., 255. / 255., 255. / 255., 1.))
Main.ligth_sun.GetLight().SetShadow(hg.LightShadowMap) # Active les ombres portées
Main.ligth_sun.GetLight().SetShadowRange(100)
Main.ligth_sun.GetLight().SetDiffuseIntensity(1.)
Main.ligth_sun.GetLight().SetSpecularIntensity(1.)
# Sky ligth:
Main.ligth_sky = plus.AddLight(Main.scene, hg.Matrix4.RotationMatrix(hg.Vector3(radians(54), radians(135), 0)),
hg.LightModelLinear)
Main.ligth_sky.SetName("SkyLigth")
Main.ligth_sky.GetLight().SetDiffuseColor(hg.Color(103. / 255., 157. / 255., 141. / 255., 1.))
Main.ligth_sky.GetLight().SetDiffuseIntensity(0.5)
# Ambient:
environment = hg.Environment()
environment.SetAmbientColor(hg.Color(103. / 255., 157. / 255., 141. / 255., 1.))
environment.SetAmbientIntensity(0.5)
Main.scene.AddComponent(environment)
def init_lights(plus, scene):
# Main light:
ligth_sun = plus.AddLight(
scene,
hg.Matrix4.RotationMatrix(hg.Vector3(radians(22), radians(-45), 0)),
hg.LightModelLinear)
ligth_sun.SetName("Sun")
ligth_sun.GetLight().SetDiffuseColor(
hg.Color(255. / 255., 255. / 255., 255. / 255., 1.))
ligth_sun.GetLight().SetShadow(
hg.LightShadowMap) # Active les ombres portées
ligth_sun.GetLight().SetShadowRange(100)
ligth_sun.GetLight().SetDiffuseIntensity(1.)
ligth_sun.GetLight().SetSpecularIntensity(1.)
# Sky ligth:
ligth_sky = plus.AddLight(
scene,
hg.Matrix4.RotationMatrix(hg.Vector3(radians(54), radians(135), 0)),
hg.LightModelLinear)
ligth_sky.SetName("SkyLigth")
ligth_sky.GetLight().SetDiffuseColor(
hg.Color(103. / 255., 157. / 255., 141. / 255., 1.))
ligth_sky.GetLight().SetDiffuseIntensity(0.9)
def update_target_sight(Main, plus, aircraft: Aircraft):
tps = hg.time_to_sec_f(plus.GetClock())
target = aircraft.get_target()
f = Main.render_to_texture.value
if target is not None:
p2D = get_2d(Main.scene.GetCurrentCamera(), plus.GetRenderer(),
target.get_parent_node().GetTransform().GetPosition())
if p2D is not None:
a_pulse = 0.5 if (sin(tps * 20) > 0) else 0.75
if aircraft.target_locked:
c = hg.Color(1., 0.5, 0.5, a_pulse)
msg = "LOCKED - " + str(int(aircraft.target_distance))
x = (p2D.x - 32 / 1600)
a = a_pulse
else:
msg = str(int(aircraft.target_distance))
x = (p2D.x - 12 / 1600)
c = hg.Color(0.5, 1, 0.5, 0.75)
c.a *= f
plus.Sprite2D(p2D.x * Main.resolution.x, p2D.y * Main.resolution.y,
32 / 1600 * Main.resolution.x,
"assets/sprites/target_sight.png", c)
if aircraft.target_out_of_range:
plus.Text2D((p2D.x - 40 / 1600) * Main.resolution.x,
(p2D.y - 24 / 900) * Main.resolution.y,
"OUT OF RANGE", 0.012 * Main.resolution.y,
hg.Color(0.2, 1, 0.2, a_pulse * f))
else:
plus.Text2D(x * Main.resolution.x,
(p2D.y - 24 / 900) * Main.resolution.y, msg,
0.012 * Main.resolution.y, c)
if aircraft.target_locking_state > 0:
t = sin(aircraft.target_locking_state * pi -
pi / 2) * 0.5 + 0.5
p2D = hg.Vector2(0.5, 0.5) * (1 - t) + p2D * t
plus.Sprite2D(p2D.x * Main.resolution.x,
p2D.y * Main.resolution.y,
32 / 1600 * Main.resolution.x,
"assets/sprites/missile_sight.png", c)
c = hg.Color(0, 1, 0, f)
plus.Text2D(0.05 * Main.resolution.x, 0.93 * Main.resolution.y,
"Target dist: %d" % (aircraft.target_distance),
0.016 * Main.resolution.y, c)
plus.Text2D(0.05 * Main.resolution.x, 0.91 * Main.resolution.y,
"Target cap: %d" % (aircraft.target_cap),
0.016 * Main.resolution.y, c)
plus.Text2D(0.05 * Main.resolution.x, 0.89 * Main.resolution.y,
"Target alt: %d" % (aircraft.target_altitude),
0.016 * Main.resolution.y, c)
def __init__(self, plus, scene, render_script: hg.RenderScript = None):
self.render_script = render_script
self.sun_light = scene.GetNode("Sun")
self.sky_light = scene.GetNode("SkyLigth")
self.sea_scale = hg.Vector3(0.02, 3, 0.005)
self.zenith_color = hg.Color(17. / 255., 56. / 255., 155. / 255., 1.)
self.horizon_N_color = hg.Color(76. / 255., 128. / 255., 255 / 255.,
1.)
self.horizon_S_color = hg.Color(76. / 255., 128. / 255., 255 / 255.,
1.)
self.sea_color = hg.Color(19 / 255., 39. / 255., 89. / 255., 1.)
self.horizon_line_color = hg.Color(1, 1, 1, 1)
self.horizon_line_size = 40
self.sea_reflection = 0.5
renderer = plus.GetRenderer()
self.sea_filtering = 0 # 1 to activate sea texture filtering
self.render_scene_reflection = False
self.max_filter_samples = 3
self.filter_precision = 10
self.shader = renderer.LoadShader(
"assets/shaders/sky_sea_render_optim.isl")
self.noise_texture_1 = renderer.LoadTexture(
"assets/textures/noise.png")
self.noise_texture_2 = renderer.LoadTexture(
"assets/textures/noise_3.png")
self.noise_displacement_texture = renderer.LoadTexture(
"assets/textures/noise_2.png")
self.stream_texture = renderer.LoadTexture(
"assets/textures/stream.png")
self.clouds_map = renderer.LoadTexture(
"assets/textures/clouds_map.png")
self.clouds_scale = hg.Vector3(1000., 0.1, 1000.)
self.clouds_altitude = 1000.
self.clouds_absorption = 0.1
self.tex_sky_N = renderer.LoadTexture("assets/skymaps/clouds.png")
self.tex_sky_N_intensity = 1
self.zenith_falloff = 4
self.reflect_map = None
self.reflect_map_depth = None
self.reflect_offset = 50
self.render_sea = True
def update_particles(self):
altitude_min = self.altitude - self.particles_scale_range.y / 2
if altitude_min > self.altitude:
altitude_max = altitude_min
altitude_min = self.altitude
else:
altitude_max = self.altitude
for i in range(0, self.num_geometries):
particles = self.particles[i]
c = hg.Color(1., 1., 1., 1.)
for particle in particles:
material = particle[0].GetMaterial(0)
t = material.IsReadyOrFailed()
if t:
material.SetFloat("alpha_cloud", c.a)
material.SetFloat3("sun_dir", self.sun_dir.x,
self.sun_dir.y, self.sun_dir.z)
material.SetFloat3("sun_color", self.sun_color.r,
self.sun_color.g, self.sun_color.b)
material.SetFloat3("ambient_color", self.ambient_color.r,
self.ambient_color.g,
self.ambient_color.b)
material.SetFloat("absorption_factor", self.absorption)
material.SetFloat("layer_dist", self.distance_min)
material.SetFloat("altitude_min", altitude_min)
material.SetFloat("altitude_max", altitude_max)
material.SetFloat("altitude_falloff",
self.altitude_falloff)
material.SetFloat("rot_speed", self.particles_rot_speed)
def display_title_screen(plus, scn): plus.Text2D(screen_width * 0.15, screen_height * 0.625, "BOULDER\nATTACKS", font_size * 4.25, hg.Color(0,0,0,0.25), screen_font) plus.Text2D(screen_width * 0.15, screen_height * 0.65, "BOULDER\nATTACKS", font_size * 4.25, hg.Color.Green, screen_font) fade = abs(sin(hg.time_to_sec_f(plus.GetClock()))) plus.Text2D(screen_width * 0.35, screen_height * 0.35, "PRESS SPACE", font_size * 1.25, hg.Color.Green * hg.Color(1, 1, 1, fade), screen_font)
def __init__(self, plus, scene, parameters: dict):
ViewTrame.__init__(self, parameters["distance_min"],
parameters["distance_max"], parameters["tile_size"],
parameters["margin"], parameters["focal_margin"])
self.name = parameters["name"]
self.billboard_type = parameters["billboard_type"]
self.particles_scale_range = list_to_vec2(
parameters["particles_scale_range"])
self.num_tiles = 0
self.num_particles = parameters["num_particles"] # List !
self.num_geometries = parameters["num_geometries"]
self.particle_index = [0] * self.num_geometries
self.particle_index_prec = [0] * self.num_geometries
self.particles_files_names = parameters[
"particles_files_names"] # List !
self.particles = []
for i in range(0, self.num_geometries):
particles = self.create_particles(plus, scene,
self.particles_files_names[i],
self.num_particles[i],
self.name + "." + str(i))
self.particles.append(particles)
self.absorption = parameters["absorption"]
self.altitude = parameters["altitude"]
self.altitude_floor = parameters["altitude_floor"]
self.alpha_threshold = parameters["alpha_threshold"]
self.scale_falloff = parameters["scale_falloff"]
self.alpha_scale_falloff = parameters["alpha_scale_falloff"]
self.altitude_falloff = parameters["altitude_falloff"]
self.perturbation = parameters["perturbation"]
self.particles_rot_speed = 0.1
if "particles_rot_speed" in parameters:
self.particles_rot_speed = parameters["particles_rot_speed"]
# map:
self.map_size = None
self.map_scale = None
self.bitmap_clouds = None
# Environment:
self.sun_dir = None
self.sun_color = None
self.ambient_color = None
# Updates vars
self.rot_hash = hg.Vector3(313.464, 7103.3, 4135.1)
self.scale_size = 0
self.pc = hg.Color(1, 1, 1, 1)
self.cam_pos = None
self.t = 0
self.morph_level = 1.2
if "morph_level" in parameters:
self.morph_level = parameters["morph_level"]
self.offset = hg.Vector2(0, 0) #Used for clouds wind displacement
self.renderable_system = scene.GetRenderableSystem()
self.smooth_alpha_threshold_step = 0.1
def display_hud(Main, plus, aircraft: Aircraft,targets): f =Main.HSL_postProcess.GetL() tps = hg.time_to_sec_f(plus.GetClock()) a_pulse = 0.1 if (sin(tps * 25) > 0) else 0.9 hs, vs = aircraft.get_world_speed() plus.Text2D(0.05 * Main.resolution.x, 0.95 * Main.resolution.y, "Health: %d" % (aircraft.health_level*100), 0.016 * Main.resolution.y, (hg.Color.White*aircraft.health_level+hg.Color.Red*(1-aircraft.health_level)) * f) plus.Text2D(0.49 * Main.resolution.x, 0.95 * Main.resolution.y, "Cap: %d" % (aircraft.cap), 0.016 * Main.resolution.y, hg.Color.White * f) plus.Text2D(0.8 * Main.resolution.x, 0.90 * Main.resolution.y, "Altitude (m): %d" % (aircraft.get_altitude()), 0.016 * Main.resolution.y, hg.Color.White * f) plus.Text2D(0.8 * Main.resolution.x, 0.88 * Main.resolution.y, "Vertical speed (m/s): %d" % (vs), 0.016 * Main.resolution.y, hg.Color.White * f) plus.Text2D(0.8 * Main.resolution.x, 0.03 * Main.resolution.y, "horizontal speed (m/s): %d" % (hs), 0.016 * Main.resolution.y, hg.Color.White * f) plus.Text2D(0.8 * Main.resolution.x, 0.13 * Main.resolution.y, "Pitch attitude: %d" % (aircraft.pitch_attitude), 0.016 * Main.resolution.y, hg.Color.White * f) plus.Text2D(0.8 * Main.resolution.x, 0.11 * Main.resolution.y, "Roll attitude: %d" % (aircraft.roll_attitude), 0.016 * Main.resolution.y, hg.Color.White * f) ls=aircraft.get_linear_speed()*3.6 plus.Text2D(0.8 * Main.resolution.x, 0.05 * Main.resolution.y, "Linear speed (km/h): %d" % (ls), 0.016 *Main. resolution.y, hg.Color.White * f) if ls<250 and not aircraft.flag_landed: plus.Text2D(749/1600 * Main.resolution.x, 120/900 * Main.resolution.y, "LOW SPEED", 0.018 * Main.resolution.y, hg.Color(1.,0,0,a_pulse)) plus.Text2D(0.8 * Main.resolution.x, 0.01 * Main.resolution.y, "Linear acceleration (m.s2): %.2f" % (Main.p1_aircraft.get_linear_acceleration()), 0.016 * Main.resolution.y, hg.Color.White * f) plus.Text2D(749 / 1600 * Main.resolution.x, 94 / 900 * Main.resolution.y, "Thrust: %d %%" % (Main.p1_aircraft.thrust_level * 100), 0.016 * Main.resolution.y, hg.Color.White * f) if Main.p1_aircraft.brake_level > 0: plus.Text2D(688 / 1600 * Main.resolution.x, 32 / 900 * Main.resolution.y, "Brake: %d %%" % (Main.p1_aircraft.brake_level * 100), 0.016 * Main.resolution.y, hg.Color(1, 0.4, 0.4) * f) if Main.p1_aircraft.flaps_level > 0: plus.Text2D(824 / 1600 * Main.resolution.x, 32 / 900 * Main.resolution.y, "Flaps: %d %%" % (Main.p1_aircraft.flaps_level * 100), 0.016 * Main.resolution.y, hg.Color(1, 0.8, 0.4) * f) #if Main.p1_aircraft.post_combution: # plus.Text2D(710 / 1600 * Main.resolution.x, 76 / 900 * Main.resolution.y, "POST COMBUSTION", 0.02 * Main.resolution.y, # hg.Color.Red) update_radar(Main, plus, aircraft, targets) update_target_sight(Main, plus, aircraft) if not Main.satellite_view: update_machine_gun_sight(Main, plus, aircraft)
def update_render_script(self, scene, resolution: hg.Vector2, time):
if self.render_sea:
self.render_script.Set("render_sea", 1)
else:
self.render_script.Set("render_sea", 0)
self.render_script.Set("zenith_color", self.zenith_color)
self.render_script.Set("horizon_N_color", self.horizon_N_color)
self.render_script.Set("horizon_S_color", self.horizon_S_color)
self.render_script.Set("zenith_falloff", self.zenith_falloff)
self.render_script.Set("horizon_line_color", self.horizon_line_color)
self.render_script.Set("sea_color", self.sea_color)
l_color = self.sun_light.GetLight().GetDiffuseColor()
self.render_script.Set("sun_color", l_color)
amb = hg.Color(scene.GetEnvironment().GetAmbientColor()
) * scene.GetEnvironment().GetAmbientIntensity()
self.render_script.Set("ambient_color", amb)
self.render_script.Set("horizon_line_size", self.horizon_line_size)
self.render_script.Set("tex_sky_N_intensity", self.tex_sky_N_intensity)
self.render_script.Set("resolution", resolution)
self.render_script.Set("clouds_scale", self.clouds_scale)
self.render_script.Set("clouds_altitude", self.clouds_altitude)
self.render_script.Set("clouds_absorption", self.clouds_absorption)
camera = scene.GetCurrentCamera()
pos = camera.GetTransform().GetPreviousWorld().GetTranslation()
camera = camera.GetCamera()
self.render_script.Set("sea_reflection", self.sea_reflection)
self.render_script.Set("sea_filtering", self.sea_filtering)
self.render_script.Set("max_filter_samples", self.max_filter_samples)
self.render_script.Set("filter_precision", self.filter_precision)
l_dir = self.sun_light.GetTransform().GetWorld().GetRotationMatrix(
).GetZ()
self.render_script.Set("sun_dir", l_dir)
self.render_script.Set("sea_scale", self.sea_scale)
self.render_script.Set("time_clock", time)
self.render_script.Set("cam_pos", pos)
self.render_script.Set("z_near", camera.GetZNear())
self.render_script.Set("z_far", camera.GetZFar())
self.render_script.Set("zoom_factor", camera.GetZoomFactor())
self.render_script.Set("reflect_map", self.reflect_map)
self.render_script.Set("reflect_map_depth", self.reflect_map_depth)
self.render_script.Set("reflect_offset", self.reflect_offset)
self.render_script.Set("tex_sky_N", self.tex_sky_N)
self.render_script.Set("noise_texture_1", self.noise_texture_1)
self.render_script.Set("noise_texture_2", self.noise_texture_2)
self.render_script.Set("noise_displacement_texture",
self.noise_displacement_texture)
self.render_script.Set("stream_texture", self.stream_texture)
self.render_script.Set("clouds_map", self.clouds_map)
if self.render_scene_reflection:
self.render_script.Set("scene_reflect", 1)
else:
self.render_script.Set("scene_reflect", 0)
def display_game_over(plus, scn, score): plus.Text2D(screen_width * 0.2, screen_height * 0.625, "GAME\n OVER", font_size * 4.25, hg.Color(0,0,0,0.25), screen_font) plus.Text2D(screen_width * 0.2, screen_height * 0.65, "GAME\n OVER", font_size * 4.25, hg.Color.Red, screen_font) plus.Text2D(screen_width * 0.3, screen_height * 0.35, "YOU SCORED " + str(score), font_size * 1.25, hg.Color.Red, screen_font) fade = abs(sin(hg.time_to_sec_f(plus.GetClock()))) plus.Text2D(screen_width * 0.3, screen_height * 0.25, "PRESS SPACE", font_size * 1.25, hg.Color.Red * hg.Color(1, 1, 1, fade), screen_font)
def update_machine_gun_sight(Main, plus, aircraft: Aircraft):
mat = aircraft.get_parent_node().GetTransform().GetWorld()
aZ = mat.GetZ()
pos = aircraft.gun_position * mat
p = pos + aZ * 500
p2D = get_2d(Main.scene.GetCurrentCamera(), plus.GetRenderer(), p)
if p2D is not None:
plus.Sprite2D(p2D.x * Main.resolution.x, p2D.y * Main.resolution.y,
64 / 1600 * Main.resolution.x,
"assets/sprites/machine_gun_sight.png",
hg.Color(0.5, 1, 0.5, Main.render_to_texture.value))
def draw(self, position, scrool_x_speed): if Main.collision_time < self.flames_delay: f = Main.collision_time / self.flames_delay color = hg.Color(hg.Color.White * 1 - f + hg.Color.Black * f) self.min_scale = 1 self.max_scale = 3 else: color = hg.Color(hg.Color.Black) self.min_scale = 0.75 self.max_scale = 1.25 self.particles_cnt_f += Main.delta_t * self.flow n = int(self.particles_cnt_f) - self.particles_cnt if n > 0: for i in range(n): particle = self.particles[(self.particles_cnt + i) % self.num_particles] particle.scale = uniform(self.min_scale, self.max_scale) particle.color = color particle.color.a = max(0.5, 1 - (particle.scale - self.min_scale) / (self.max_scale - self.min_scale)) particle.age = 0 particle.position = hg.Vec2(position) particle.x_speed = uniform(-0.02, 0.02) self.particles_cnt += n for particle in self.particles: if 0 <= particle.age < self.particles_delay: particle.position.y += Main.delta_t * self.y_speed particle.position.x += scrool_x_speed + particle.x_speed * Main.delta_t particle.angle -= 1.8 * Main.delta_t particle.age += Main.delta_t t = particle.age / self.particles_delay self.sprite.scale = self.main_scale * particle.scale * (self.start_scale * (1 - t) + self.end_scale * t) color = hg.Color(particle.color) color.a *= (1 - t) self.sprite.draw_rot(particle.angle, particle.position, color)
def __init__(self, plus, scene, resolution: hg.Vector2, texture_width=256):
renderer = plus.GetRenderer()
render_system = plus.GetRenderSystem()
# Parameters:
self.color = hg.Color(1, 1, 0, 1)
self.reflect_level = 0.75
# Shaders:
# self.shader_water_reflection = render_system.LoadSurfaceShader("assets/shaders/water_reflection.isl")
# Reflection plane, just to get normal & origine:
# self.plane=plus.AddPlane(scene, hg.Matrix4.TransformationMatrix(hg.Vector3(0,0,0), hg.Vector3(radians(0), radians(0), radians(0))), 1, 1)
# self.plane.SetName("Water_Reflection_Plane")
# Création des textures de rendu:
tex_res = hg.Vector2(texture_width,
texture_width * resolution.y / resolution.x)
self.render_texture = renderer.NewTexture()
renderer.CreateTexture(self.render_texture, int(tex_res.x),
int(tex_res.y), hg.TextureRGBA8, hg.TextureNoAA,
0, False)
self.render_depth_texture = renderer.NewTexture()
renderer.CreateTexture(self.render_depth_texture, int(tex_res.x),
int(tex_res.y), hg.TextureDepth, hg.TextureNoAA,
0, False)
# Création des frameBuffer objects:
self.render_target = renderer.NewRenderTarget()
renderer.CreateRenderTarget(self.render_target)
renderer.SetRenderTargetColorTexture(self.render_target,
self.render_texture)
renderer.SetRenderTargetDepthTexture(self.render_target,
self.render_depth_texture)
self.projection_matrix_mem = None
self.view_matrix_mem = None
self.projection_matrix_ortho = None
# Reflection camera:
self.camera_reflect = plus.AddCamera(
scene, hg.Matrix4.TranslationMatrix(hg.Vector3(0, -2, 0)))
self.camera_reflect.SetName("Camera.water_reflection")
self.clear_reflect_map(plus)
def update(self, t, camera, resolution, map_position: hg.Vector2):
self.offset = map_position
self.t = t
self.num_tiles = 0
self.particle_index_prec = self.particle_index
self.particle_index = [0] * self.num_geometries
# for i in range (0,self.num_textures_layer_2):
# self.particle_index_layer_2.append(0)
self.cam_pos = camera.GetTransform().GetPosition()
self.pc = hg.Color(1., 1., 1., 1.)
self.scale_size = self.particles_scale_range.y - self.particles_scale_range.x
self.rot_hash = hg.Vector3(133.464, 4713.3, 1435.1)
self.send_position = self.set_particle
self.update_triangle(
resolution,
camera.GetTransform().GetPosition() +
hg.Vector3(self.offset.x, 0, self.offset.y),
camera.GetTransform().GetWorld().GetZ(),
camera.GetCamera().GetZoomFactor())
self.fill_triangle()
def update_animation(self, time): # Start animation: if self.start_date < 0: self.start_date = time return True # Interpolate position / orientation / color: if self.start_date + self.start_delay < time: if self.start_date + self.duration + self.start_delay > time: tl = (time - self.start_date - self.start_delay) / self.duration t = pow(sin(tl * pi / 2), 4) self.sprite.position = (self.start_position * (1 - t) + self.end_position * t) self.sprite.color = hg.Color(self.start_color * (1 - tl) + self.end_color * tl) return True # End of animation: else: return False else: return True
def reset_intro_phase(): Main.pillars_doors, Main.pillars_bottom = [], [] Main.ship.reset() Main.flames.reset() Main.scrolling_speed = 0.9 Main.sprites["vapors"][0].position = hg.Vec2() Main.sprites["vapors"][1].position = hg.Vec2() random_vapor_pos(0) random_vapor_pos(1) Main.doors_counter = 0 Main.sprites["title"].position = hg.Vec2(0.5, convy(300)) Main.sprites["explain"].position = hg.Vec2(0.5, 0.67) Main.sprites["explain"].color = hg.Color(1, 1, 1, 0) Main.animations = [SpriteAnimator(Main.sprites["title"], hg.Vec2(0.5, convy(221)), hg.Color.White, 0, 0.5), SpriteAnimator(Main.sprites["explain"], hg.Vec2(0.5, 0.67), hg.Color.White, 0.5, 0.5)] for sprite in Main.sprites["difficulty_level"].values(): sprite.position=hg.Vec2(0.5,convy(120))
def __init__(self, plus, scene):
self.lumiere_soleil = scene.GetNode("Sun")
self.lumiere_ciel = scene.GetNode("SkyLigth")
self.couleur_horizon = hg.Color(255. / 255. * 0.75, 221. / 255. * 0.75,
199 / 255. * 0.75, 1.)
# self.couleur_zenith=hg.Color(255/255.,252./255.,171./255.,1.)
self.couleur_zenith = hg.Color(70. / 255. / 2, 150. / 255. / 2,
255. / 255. / 2, 1.)
self.couleur_ambiante = hg.Color(78. / 255., 119. / 255., 107. / 255.,
1.)
# self.couleur_ambiante=hg.Color(1,0,0,1)
renderer = plus.GetRenderer()
# -------------- Init le shader de rendu de terrain:
self.shader_terrain = renderer.LoadShader(
"assets/shaders/terrain_marching_montagnes.isl")
self.texture_terrain1 = renderer.LoadTexture(
"assets/textures/terrain_1.png")
self.texture_terrain2 = renderer.LoadTexture(
"assets/textures/terrain_256.png")
self.texture_terrain3 = renderer.LoadTexture(
"assets/textures/terrain_2048.png")
self.texture_cosmos = renderer.LoadTexture(
"assets/textures/cosmos_b.png")
self.facteur_echelle_terrain_l1 = hg.Vector2(20000, 20000)
self.facteur_echelle_terrain_l2 = hg.Vector2(1000, 1000)
self.facteur_echelle_terrain_l3 = hg.Vector2(100, 100)
self.amplitude_l1 = 1000
self.amplitude_l2 = 90
self.amplitude_l3 = 1.5
self.terrain_intensite_ambiante = 0.2
self.offset_terrain = hg.Vector3(0, -50, 0)
self.facteur_precision_distance = 1.01
self.couleur_neige = hg.Color(0.91 * 0.75, 0.91 * 0.75, 1 * 0.75)
self.couleur_cristaux = hg.Color(133 / 255, 225 / 255, 181 / 255, 1)
self.couleur_eau = hg.Color(117. / 255., 219. / 255., 211. / 255.)
self.altitude_eau = 0
self.reflexion_eau = 0.5
self.intensite_cristaux = 3
res_x, res_y = 1280, 720
win = hg.NewWindow(res_x, res_y)
hg.RenderInit(win)
hg.RenderReset(res_x, res_y, hg.ResetVSync | hg.ResetMSAA4X)
hg.AddAssetsFolder("../3d-fight_compiled/")
imgui_prg = hg.LoadProgramFromAssets('core/shader/imgui')
imgui_img_prg = hg.LoadProgramFromAssets('core/shader/imgui_image')
hg.ImGuiInit(10, imgui_prg, imgui_img_prg)
check = True
open = True
combo = 0
color = hg.Color(1, 0, 1)
# hg.SetRenderDebug(hg.RenderDebugProfiler | hg.RenderDebugStats | hg.RenderDebugText)
# Vertex model:
vs_decl = hg.VertexDecl()
vs_decl.Begin()
vs_decl.Add(hg.A_Position, 3, hg.AT_Float)
vs_decl.Add(hg.A_Normal, 3, hg.AT_Uint8, True, True)
vs_decl.End()
# Geometries models:
res = hg.PipelineResources()
cube_mdl = hg.CreateCubeModel(vs_decl, 0.5, 0.5, 0.5)
cube_ref = res.AddModel('cube', cube_mdl)
def list_to_color(c: list):
return hg.Color(c[0], c[1], c[2], c[3])
import harfang as hg
hg.LoadPlugins()
# mount data folder
hg.MountFileDriver(hg.StdFileDriver("_data"), "@data")
# create the renderer
plus = hg.GetPlus()
plus.RenderInit(1280, 720, 4)
# create scene
scn = plus.NewScene(False, True)
plus.AddEnvironment(scn, hg.Color.Black, hg.Color.Black,
hg.Color(0.85, 0.9, 1), 8000, 60000)
# camera
cam = plus.AddCamera(scn)
cam.GetCamera().SetZNear(1)
cam.GetCamera().SetZFar(100000) # 100km
# sky lighting
sky = hg.RenderScript("@core/lua/sky_lighting.lua")
sky.Set("time_of_day", 16.5)
sky.Set("attenuation", 0.75)
sky.Set("shadow_range", 10000.0) # 10km shadow range
sky.Set("shadow_split", hg.Vector4(0.1, 0.2, 0.3, 0.4))
scn.AddComponent(sky)
# load terrain
plus = hg.GetPlus() # initialize rendering plus.CreateWorkers() plus.RenderInit(1280, 720) # create the scene and retrieve its physic system scn = plus.NewScene() physic_system = scn.GetPhysicSystem() physic_system.SetTimestep(1 / 200) # raise physic frequency for more stability # create default content cam = plus.AddCamera(scn, hg.Matrix4.TranslationMatrix(hg.Vector3(0, 1, -10))) plus.AddLight(scn, hg.Matrix4.RotationMatrix(hg.Vector3(0.6, -0.4, 0)), hg.LightModelLinear, 150) plus.AddLight(scn, hg.Matrix4.RotationMatrix(hg.Vector3(0.6, pi, 0.2)), hg.LightModelLinear, 0, False, hg.Color(0.3, 0.3, 0.4)) plus.AddPhysicPlane(scn) # create the initial tower tower_radius = 6 tower_height = 16 nodes = add_kapla_tower(scn, 0.5, 2, 2, tower_radius, tower_height) # create the FPS controller fps = hg.FPSController(0, 16, -80) # enter the simulation loop while not plus.IsAppEnded(): # handle inputs old_tower_radius, old_tower_height = tower_radius, tower_height
import harfang as hg
hg.LoadPlugins()
hg.MountFileDriver(hg.StdFileDriver("_data/"))
resolution = hg.Vector2(1280, 720)
antialiasing = 4
plus = hg.GetPlus()
plus.RenderInit(int(resolution.x), int(resolution.y), antialiasing)
# setup scene
scn = plus.NewScene(False, False)
plus.AddEnvironment(scn,hg.Color.Black, hg.Color(0.25, 0.25, 0.3))
cam = plus.AddCamera(scn, hg.Matrix4.TransformationMatrix(hg.Vector3(0, 65, -55), hg.Vector3(0.9, 0, 0)))
lgt = plus.AddLight(scn, hg.Matrix4.TransformationMatrix(hg.Vector3(40, 50, -60), hg.Vector3(0.75, -0.6, 0)), hg.LightModelSpot)
lgt.GetLight().SetConeAngle(0.49)
lgt.GetLight().SetEdgeAngle(0.1)
gfx = hg.SimpleGraphicSceneOverlay(False)
scn.AddComponent(gfx)
# create the navigation system and component
nav_sys = hg.NavigationSystem()
nav_sys.SetDebugVisuals(False)
scn.AddSystem(nav_sys)
geo = hg.Geometry()
def update_radar(Main, plus, aircraft, targets):
value = Main.render_to_texture.value
t = hg.time_to_sec_f(plus.GetClock())
rx, ry = 150 / 1600 * Main.resolution.x, 150 / 900 * Main.resolution.y
rs = 200 / 1600 * Main.resolution.x
rm = 6 / 1600 * Main.resolution.x
radar_scale = 4000
plot_size = 12 / 1600 * Main.resolution.x / 2
plus.Sprite2D(rx, ry, rs, "assets/sprites/radar.png",
hg.Color(1, 1, 1, value))
mat = aircraft.get_parent_node().GetTransform().GetWorld()
aZ = mat.GetZ()
aZ.y = 0
aZ.Normalize()
aY = mat.GetY()
if aY.y < 0:
aY = hg.Vector3(0, -1, 0)
else:
aY = hg.Vector3(0, 1, 0)
aX = hg.Cross(aY, aZ)
mat_trans = hg.Matrix4.TransformationMatrix(mat.GetTranslation(),
hg.Matrix3(aX, aY,
aZ)).InversedFast()
for target in targets:
if not target.wreck and target.activated:
t_mat = target.get_parent_node().GetTransform().GetWorld()
aZ = t_mat.GetZ()
aZ.y = 0
aZ.Normalize()
aY = hg.Vector3(0, 1, 0)
aX = hg.Cross(aY, aZ)
t_mat_trans = mat_trans * hg.Matrix4.TransformationMatrix(
t_mat.GetTranslation(), hg.Matrix3(aX, aY, aZ))
pos = t_mat_trans.GetTranslation()
v2D = hg.Vector2(pos.x, pos.z) / radar_scale * rs / 2
if abs(v2D.x) < rs / 2 - rm and abs(v2D.y) < rs / 2 - rm:
if target.type == Destroyable_Machine.TYPE_MISSILE:
plot = Main.texture_hud_plot_missile
elif target.type == Destroyable_Machine.TYPE_AIRCRAFT:
plot = Main.texture_hud_plot_aircraft
elif target.type == Destroyable_Machine.TYPE_SHIP:
plot = Main.texture_hud_plot_ship
t_mat_rot = t_mat_trans.GetRotationMatrix()
ps = plot_size
a = 0.5 + 0.5 * abs(sin(t * uniform(1, 500)))
else:
if target.type == Destroyable_Machine.TYPE_MISSILE: continue
dir = v2D.Normalized()
v2D = dir * (rs / 2 - rm)
ps = plot_size
plot = Main.texture_hud_plot_dir
aZ = hg.Vector3(dir.x, 0, dir.y)
aX = hg.Cross(hg.Vector3.Up, aZ)
t_mat_rot = hg.Matrix3(aX, hg.Vector3.Up, aZ)
a = 0.5 + 0.5 * abs(sin(t * uniform(1, 500)))
cx, cy = rx + v2D.x, ry + v2D.y
if target.nationality == 1:
c = hg.Color(0.25, 1., 0.25, a)
elif target.nationality == 2:
c = hg.Color(1., 0.5, 0.5, a)
c.a *= value
p1 = t_mat_rot * hg.Vector3(-plot_size, 0, -ps)
p2 = t_mat_rot * hg.Vector3(-plot_size, 0, ps)
p3 = t_mat_rot * hg.Vector3(plot_size, 0, ps)
p4 = t_mat_rot * hg.Vector3(plot_size, 0, -ps)
plus.Quad2D(cx + p1.x, cy + p1.z, cx + p2.x, cy + p2.z, cx + p3.x,
cy + p3.z, cx + p4.x, cy + p4.z, c, c, c, c, plot)
c = hg.Color(1, 1, 1, value * max(pow(1 - aircraft.health_level, 2), 0.05))
plus.Quad2D(rx - rs / 2, ry - rs / 2, rx - rs / 2, ry + rs / 2,
rx + rs / 2, ry + rs / 2, rx + rs / 2, ry - rs / 2, c, c, c, c,
Main.texture_noise, 0.25 + 0.25 * sin(t * 103),
(0.65 + 0.35 * sin(t * 83)), 0.75 + 0.25 * sin(t * 538),
0.75 + 0.25 * cos(t * 120))
c = hg.Color(1, 1, 1, value)
plus.Sprite2D(rx, ry, rs, "assets/sprites/radar_light.png",
hg.Color(1, 1, 1, 0.3 * value))
plus.Sprite2D(rx, ry, rs, "assets/sprites/radar_box.png", c)
def draw_flash(): Main.collision_time += Main.delta_t if Main.collision_time < Main.flash_delay: f = Main.collision_time / Main.flash_delay color = hg.Color(1, 1, 1, 1 - f)
# Display a scene using isometric projection
import harfang as hg
import math
hg.LoadPlugins()
# create the renderer
plus = hg.GetPlus()
plus.RenderInit(1280, 720)
# configure scene
scn = plus.NewScene()
plus.AddEnvironment(scn, hg.Color(0, 0, 0.1), hg.Color(0.1, 0.1, 0.2))
cam = plus.AddCamera(
scn,
hg.Matrix4.TransformationMatrix(hg.Vector3(0, 0.5, -2),
hg.Vector3(0.25, 0, 0)), True)
cam.GetCamera().SetOrthographicSize(1.3)
cam.GetCamera().SetZNear(0.1)
cam.GetCamera().SetZFar(10)
plus.AddLight(
scn,
hg.Matrix4.TransformationMatrix(hg.Vector3.Zero, hg.Vector3(0.075, 0, 0)),
hg.LightModelLinear, 50)
plus.AddPlane(scn, hg.Matrix4.Identity, 1, 1)
# create a few boxes
boxes = []
def update_shader(self, plus, scene, resolution, time):
camera = scene.GetCurrentCamera()
renderer = plus.GetRenderer()
renderer.EnableDepthTest(True)
renderer.EnableDepthWrite(True)
renderer.EnableBlending(False)
renderer.SetShader(self.shader)
renderer.SetShaderInt("sea_filtering", self.sea_filtering)
renderer.SetShaderInt("max_samples", self.max_filter_samples)
renderer.SetShaderFloat("filter_precision", self.filter_precision)
renderer.SetShaderFloat("reflect_offset", self.reflect_offset)
renderer.SetShaderTexture("tex_sky_N", self.tex_sky_N)
renderer.SetShaderTexture("reflect_map", self.reflect_map)
renderer.SetShaderTexture("reflect_map_depth", self.reflect_map_depth)
renderer.SetShaderTexture("noise_texture_1", self.noise_texture_1)
renderer.SetShaderTexture("noise_texture_2", self.noise_texture_2)
renderer.SetShaderTexture("displacement_texture",
self.noise_displacement_texture)
renderer.SetShaderTexture("stream_texture", self.stream_texture)
renderer.SetShaderTexture("clouds_map", self.clouds_map)
renderer.SetShaderFloat3("clouds_scale", 1. / self.clouds_scale.x,
self.clouds_scale.y, 1. / self.clouds_scale.z)
renderer.SetShaderFloat("clouds_altitude", self.clouds_altitude)
renderer.SetShaderFloat("clouds_absorption", self.clouds_absorption)
# renderer.SetShaderFloat2("stream_scale",self.stream_scale.x,.y)
renderer.SetShaderFloat2("resolution", resolution.x, resolution.y)
renderer.SetShaderFloat("focal_distance",
camera.GetCamera().GetZoomFactor())
renderer.SetShaderFloat("tex_sky_N_intensity",
self.tex_sky_N_intensity)
renderer.SetShaderFloat("zenith_falloff", self.zenith_falloff)
cam = camera.GetTransform().GetPreviousWorld()
pos = cam.GetTranslation()
renderer.SetShaderFloat3("cam_position", pos.x, pos.y, pos.z)
renderer.SetShaderMatrix3("cam_normal", cam.GetRotationMatrix())
renderer.SetShaderFloat3("sea_scale", 1 / self.sea_scale.x,
self.sea_scale.y, 1 / self.sea_scale.z)
renderer.SetShaderFloat("time", time)
renderer.SetShaderFloat3("zenith_color", self.zenith_color.r,
self.zenith_color.g, self.zenith_color.b)
renderer.SetShaderFloat3("horizonH_color", self.horizon_N_color.r,
self.horizon_N_color.g,
self.horizon_N_color.b)
renderer.SetShaderFloat3("horizonL_color", self.horizon_S_color.r,
self.horizon_S_color.g,
self.horizon_S_color.b)
renderer.SetShaderFloat3("sea_color", self.sea_color.r,
self.sea_color.g, self.sea_color.b)
renderer.SetShaderFloat3("horizon_line_color",
self.horizon_line_color.r,
self.horizon_line_color.g,
self.horizon_line_color.b)
renderer.SetShaderFloat("sea_reflection", self.sea_reflection)
renderer.SetShaderFloat("horizon_line_size", self.horizon_line_size)
l_dir = self.sun_light.GetTransform().GetWorld().GetRotationMatrix(
).GetZ()
renderer.SetShaderFloat3("sun_dir", l_dir.x, l_dir.y, l_dir.z)
l_couleur = self.sun_light.GetLight().GetDiffuseColor()
renderer.SetShaderFloat3("sun_color", l_couleur.r, l_couleur.g,
l_couleur.b)
amb = hg.Color(scene.GetEnvironment().GetAmbientColor()
) * scene.GetEnvironment().GetAmbientIntensity()
renderer.SetShaderFloat3("ambient_color", amb.r, amb.g, amb.b)
renderer.SetShaderFloat2("zFrustum",
camera.GetCamera().GetZNear(),
camera.GetCamera().GetZFar())
if self.render_scene_reflection:
renderer.SetShaderInt("scene_reflect", 1)
else:
renderer.SetShaderInt("scene_reflect", 0)
def clear_reflect_map(self, plus):
renderer = plus.GetRenderer()
renderer.SetRenderTarget(self.render_target)
renderer.Clear(hg.Color(0., 0., 0., 0.))
draw_needle((date.second / 60) * math.pi*2, radius * 0.9, radius * 0.015)
# get keyboard device
keyboard = hg.GetInputSystem().GetDevice("keyboard")
# continue while the window is open
while hg.IsWindowOpen(win) and (not keyboard.WasPressed(hg.KeyEscape)):
ok,width,height = hg.GetWindowClientSize(win)
renderer.SetViewport(hg.Rect(0, 0, width, height))
# set perspective matrix
persp_mat = hg.ComputePerspectiveProjectionMatrix(0.1, 100, 3.2, renderer.GetAspectRatio())
renderer.SetProjectionMatrix(persp_mat)
# clear the viewport with green color
renderer.Clear(hg.Color(0.05, 0.05, 0.05, 0))
# blit the picture with the clock in a texture
draw_clock()
renderer.BlitTexture(tex, pic)
# draw the triangle using the render system
x, y, z, w = 2.0, 1.5, 10, 0.55
vertices = [hg.Vector3(-x, -y + w, z*0.5), hg.Vector3(-x, y + w, z), hg.Vector3(x, y + w, z),
hg.Vector3(-x, -y + w, z*0.5), hg.Vector3(x, y + w, z), hg.Vector3(x, -y + w, z*0.5)]
uvs = [hg.Vector2(1, 1), hg.Vector2(1, 0), hg.Vector2(0, 0),
hg.Vector2(1, 1), hg.Vector2(0, 0), hg.Vector2(0, 1)]
render_system.DrawTriangleAuto(2, vertices, [], uvs, tex)
renderer.DrawFrame()
def render(self,
plus,
scene,
camera,
disable_render_scripts=False,
mat_camera=None):
renderer = plus.GetRenderer()
# Clipping plane:
# mat=self.plane.GetTransform().GetWorld()
# plane_pos=mat.GetTranslation()
# plane_normal=mat.GetY()
# renderer.SetClippingPlane(plane_pos+plane_normal*0.01, plane_normal)
plane_pos = hg.Vector3(0, 0, 0)
plane_normal = hg.Vector3(0, 1, 0)
# Camera reflect:
if mat_camera is not None:
mat = mat_camera
else:
mat = camera.GetTransform().GetWorld()
pos = mat.GetTranslation()
t = self.get_plane_projection_factor(pos, plane_pos, plane_normal)
pos_reflect = pos + plane_normal * 2 * t
xAxis = mat.GetX()
zAxis = mat.GetZ()
px = pos + xAxis
tx = self.get_plane_projection_factor(px, plane_pos, plane_normal)
x_reflect = px + plane_normal * 2 * tx - pos_reflect
z_reflect = hg.Reflect(zAxis, plane_normal)
y_reflect = hg.Cross(z_reflect, x_reflect)
mat.SetTranslation(pos_reflect)
mat.SetX(x_reflect)
mat.SetY(y_reflect)
mat.SetZ(z_reflect)
self.camera_reflect.GetTransform().SetWorld(mat)
scene.SetCurrentCamera(self.camera_reflect)
cam_org = camera.GetCamera()
cam = self.camera_reflect.GetCamera()
cam.SetZoomFactor(cam_org.GetZoomFactor())
cam.SetZNear(cam_org.GetZNear())
cam.SetZFar(cam_org.GetZFar())
# Render target:
vp_mem = renderer.GetViewport()
rect = self.render_texture.GetRect()
renderer.SetViewport(rect)
renderer.SetRenderTarget(self.render_target)
renderer.Clear(hg.Color(0., 0., 0., 0.))
if disable_render_scripts:
enabled_list = []
render_scripts = scene.GetComponents("RenderScript")
for rs in render_scripts:
enabled_list.append(rs.GetEnabled())
rs.SetEnabled(False)
scene.Commit()
scene.WaitCommit()
plus.UpdateScene(scene)
# Update reflection texture:
# material = self.plane.GetObject().GetGeometry().GetMaterial(0)
# material.SetTexture("reflect_map", self.render_texture)
# material.SetFloat("reflect_level", self.reflect_level)
# material.SetFloat4("color", self.color.r,self.color.g,self.color.b,self.color.a)
# System restauration
scene.SetCurrentCamera(camera)
renderer.ClearRenderTarget()
# renderer.ClearClippingPlane()
renderer.SetViewport(vp_mem)
if disable_render_scripts:
for rs in enumerate(render_scripts):
if enabled_list[rs[0]]:
rs[1].SetEnabled(True)
scene.Commit()
scene.WaitCommit()
