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 setup_game_level(plus=None): scn = plus.NewScene() while not scn.IsReady(): plus.UpdateScene(scn, plus.UpdateClock()) scn.GetPhysicSystem().SetDebugVisuals(False) # Create a camera cam_matrix = hg.Matrix4.TransformationMatrix(hg.Vector3(0, 15, 3), hg.Vector3(radians(90), 0, 0)) cam = plus.AddCamera(scn, cam_matrix) # Ambient Occlusion pp_sao = hg.SAOPostProcess() cam.AddComponent(pp_sao) pp_sao.SetStrength(0.35) pp_sao.SetStrength(0.35) pp_sao.SetRadius(15.0) pp_sao.SetSampleCount(8) plus.AddLight(scn, hg.Matrix4.TransformationMatrix(hg.Vector3(-10, 10, 5), hg.Vector3(radians(55), radians(100), 0)), hg.LightModelSpot, 40.0, True) env_blue = hg.Color.Blue + hg.Color.Green * 0.5 plus.AddLight(scn, hg.Matrix4.TranslationMatrix(hg.Vector3(10, -25, -5)), hg.LightModelPoint, 0.0, False, env_blue, hg.Color.Black) plus.AddEnvironment(scn, hg.Color.Black, env_blue * 0.35) ground = plus.AddPhysicPlane(scn) return scn, ground
def __init__(self, node: hg.Node): self.node = node self.age = -1 self.v_move = hg.Vector3(0, 0, 0) self.delay = 0 self.scale = 1 self.rot_speed = hg.Vector3(0, 0, 0)
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_particles(dt_sec, start_pos, direction):
global spawn_rate_control
spawn_rate_control -= dt_sec
for i in range(particle_count):
particle = particles[i]
if particle['life'] > 0:
particle['life'] -= dt_sec # update life
elif spawn_rate_control < 0:
spawn_rate_control += 1 / particle_spawn_rate
# teleport the particle rigid body to its spawn position, wake it up and reset its world matrix
rigid_body = particle['body']
particle['life'] = particle_count / particle_spawn_rate
rigid_body.SetIsSleeping(False)
rigid_body.ResetWorld(
hg.Matrix4.TransformationMatrix(
start_pos,
hg.Vector3(random.random(), random.random(),
random.random())))
rigid_body.ApplyLinearImpulse(direction +
hg.Vector3(random.random() * 0.5,
random.random() * 0.5,
random.random() * 0.5))
def init_scene(plus):
Main.scene = plus.NewScene()
Main.camera = plus.AddCamera(Main.scene, hg.Matrix4.TranslationMatrix(hg.Vector3(0, 10, -10)))
Main.camera.SetName("Camera")
Main.camera.GetCamera().SetZNear(1.)
Main.camera.GetCamera().SetZFar(40000)
plus.LoadScene(Main.scene, "assets/aircraft/aircraft.scn")
plus.LoadScene(Main.scene, "assets/ennemyaircraft/ennemy_aircraft.scn")
plus.LoadScene(Main.scene, "assets/aircraft_carrier/aircraft_carrier.scn")
plus.LoadScene(Main.scene, "assets/island/island.scn")
plus.LoadScene(Main.scene, "assets/feed_backs/feed_backs.scn")
init_lights(plus)
while not Main.scene.IsReady(): # Wait until scene is ready
#plus.UpdateScene(Main.scene, plus.UpdateClock())
Main.scene.Commit()
Main.scene.WaitCommit()
#for i in range(256):
# plus.UpdateScene(Main.scene, plus.UpdateClock())
# Main.scene.Commit()
# Main.scene.WaitCommit()
Main.satellite_camera = plus.AddCamera(Main.scene, hg.Matrix4.TranslationMatrix(hg.Vector3(0, 1000, 0)))
setup_satellite_camera(Main.satellite_camera)
# ---- Clouds:
json_script = hg.GetFilesystem().FileToString("assets/scripts/clouds_parameters.json")
if json_script != "":
clouds_parameters = json.loads(json_script)
Main.clouds = Clouds(plus, Main.scene, Main.scene.GetNode("Sun"), Main.resolution, clouds_parameters)
Main.island = Main.scene.GetNode("island")
Main.island.GetTransform().SetPosition(hg.Vector3(0, 0, 3000))
Main.island.GetTransform().SetRotation(hg.Vector3(0, 0, 0))
Main.sea_render_script = hg.RenderScript("assets/lua_scripts/sea_render.lua")
Main.sea_render_script.SetEnabled(False)
Main.sea_render = SeaRender(plus, Main.scene, Main.sea_render_script)
Main.sea_render.load_json_script()
Main.sea_render.update_render_script(Main.scene, Main.resolution, hg.time_to_sec_f(plus.GetClock()))
Main.scene.AddComponent(Main.sea_render_script)
Main.water_reflection = WaterReflection(plus, Main.scene, Main.resolution, Main.resolution.x / 4)
#Main.clouds_render_script=hg.LogicScript("assets/lua_scripts/clouds_render.lua")
#Main.scene.AddComponent(Main.clouds_render_script)
#plus.UpdateScene(Main.scene)
Main.scene.Commit()
Main.scene.WaitCommit()
load_scene_parameters()
def create_slow_scene():
scn = plus.NewScene()
plus.AddCamera(scn, hg.Matrix4.TranslationMatrix(hg.Vector3(0, 0, -10)))
plus.AddLight(scn, hg.Matrix4.RotationMatrix(hg.Vector3(0.6, -0.4, 0)), hg.LightModelLinear, 100, False)
cube = plus.AddCube(scn, hg.Matrix4.Identity, 5, 1, 1)
cube.AddComponent(hg.LogicScript("@data/spin_and_sleep.lua"))
return scn
def create_box(pos = hg.Vector3(), rot = hg.Vector3(), width = 1.0, height = 1.0): node = hg.Node() object = hg.Object() transform = hg.Transform() transform.SetPosition(pos + hg.Vector3(0, height * 0.5, 0)) transform.SetRotation(rot) node.AddComponent(transform) object.SetGeometry(render_system.CreateGeometry(hg.CreateCube(width, height, width))) node.AddComponent(object) return node
def draw_circle(scene_simple_graphic, world, r, color=hg.Color.White):
step = 50
prev = hg.Vector3(math.cos(0) * r, 0, math.sin(0) * r) * world
for i in range(step + 1):
val = hg.Vector3(
math.cos(math.pi * 2 * float(i) / step) * r, 0,
math.sin(math.pi * 2 * float(i) / step) * r) * world
scene_simple_graphic.Line(prev.x, prev.y, prev.z, val.x, val.y, val.z,
color, color)
prev = val
def create_fast_scene():
scn = plus.NewScene()
plus.AddEnvironment(scn, hg.Color.Transparent, hg.Color.Black) # clear color to transparent
plus.AddCamera(scn, hg.Matrix4.TranslationMatrix(hg.Vector3(0, 0, -10)))
plus.AddLight(scn, hg.Matrix4.TranslationMatrix(hg.Vector3(6, 4, -6)))
cube = plus.AddCube(scn)
cube.AddComponent(hg.LogicScript("@data/spin.lua"))
return scn
def create_link(node): other_node, other_body = plus.AddPhysicSphere(scn, hg.Matrix4.TranslationMatrix( node.GetTransform().GetPosition() + hg.Vector3(1, 0, 0)), 0.5, 6, 16, 10) joint = hg.SphericalJoint() joint.SetOtherBody(other_node) joint.SetPivot(hg.Vector3(0.5, 0, 0)) joint.SetOtherPivot(hg.Vector3(-0.5, 0, 0)) node.AddComponent(joint) return other_node
def create_turret(plus=None, scn=None, pos=hg.Vector3(0, 0.75, 0), rot=hg.Vector3(), w=1, h=1.25, d=1, mass = 10):
scn.GetPhysicSystem().SetForceRigidBodyAxisLockOnCreation(hg.AxisLockX + hg.AxisLockY + hg.AxisLockZ + hg.AxisLockRotX + hg.AxisLockRotZ)
root = plus.AddPhysicCube(scn, hg.Matrix4.TransformationMatrix(pos, rot), w, h, d, mass)
root[0].SetName('turret')
root[1].SetAngularDamping(1.0)
cannon_geo = plus.CreateGeometry(plus.CreateCylinder(w * 0.25, d))
cannon = plus.AddObject(scn, cannon_geo, hg.Matrix4.TransformationMatrix(hg.Vector3(0, h * 0.2, d * 0.75),
hg.Vector3(radians(90), 0, 0)))
cannon.GetTransform().SetParent(root[0])
return root, cannon, mass
def get_direction(self, main_dir): if self.stream_angle == 0: return main_dir axe0 = hg.Vector3(0, 0, 0) axeRot = hg.Vector3(0, 0, 0) while axeRot.Len() < 1e-4: while axe0.Len() < 1e-5: axe0 = hg.Vector3(uniform(-1, 1), uniform(-1, 1), uniform(-1, 1)) axe0.Normalize() axeRot = hg.Cross(axe0, main_dir) axeRot.Normalize() return MathsSupp.rotate_vector(main_dir, axeRot, random() * radians(self.stream_angle))
def fill_ring(r, ring_y, size, r_adjust, y_off):
step = asin((size * 1.01) / 2 / (r - r_adjust)) * 2
cube_count = (2 * pi) // step
error = 2 * pi - step * cube_count
step += error / cube_count # distribute error
a = 0
while a < (2 * pi - error):
world = hg.Matrix4.TransformationMatrix(
hg.Vector3(cos(a) * r + x, ring_y,
sin(a) * r + z), hg.Vector3(0, -a + y_off, 0))
plus.AddPhysicCube(scn, world, width, height, length, 2)
a += step
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 load_json_matrix(file_name="assets/scripts/camera_positions.json"):
json_script = hg.GetFilesystem().FileToString(file_name)
if json_script != "":
pos = hg.Vector3()
rot = hg.Vector3()
script_parameters = json.loads(json_script)
pos.x = script_parameters["x"]
pos.y = script_parameters["y"]
pos.z = script_parameters["z"]
rot.x = script_parameters["rot_x"]
rot.y = script_parameters["rot_y"]
rot.z = script_parameters["rot_z"]
return pos, rot
return None, None
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 set_particle(self, position: hg.Vector2):
self.num_tiles += 1
# x = int(position.x / self.map_scale.x * self.map_size.x)
# y = int(position.y / self.map_scale.y * self.map_size.y)
# c = self.bitmap_clouds.GetPixelRGBA(int(x % self.map_size.x), int(y % self.map_size.y))
c = self.get_pixel_bilinear(
(position + self.offset * self.morph_level) / self.map_scale)
scale_factor = pow(c.x, self.scale_falloff)
# id = int(max(0,scale_factor - self.layer_2_alpha_threshold) / (1 - self.layer_2_alpha_threshold) * 7)
id = int(
(sin(position.x * 1735.972 + position.y * 345.145) * 0.5 + 0.5) *
(self.num_geometries - 1))
if self.particle_index[id] < self.num_particles[id]:
particle = self.particles[id][self.particle_index[id]]
if c.x > self.alpha_threshold:
smooth_alpha_threshold = min(1, (c.x - self.alpha_threshold) /
self.smooth_alpha_threshold_step)
s = self.particles_scale_range.x + scale_factor * self.scale_size
py = self.altitude + s * self.altitude_floor + (
self.perturbation * (1 - c.x) * sin(position.x * 213))
pos = hg.Vector3(position.x - self.offset.x, py,
position.y - self.offset.y)
d = (hg.Vector2(pos.x, pos.z) -
hg.Vector2(self.cam_pos.x, self.cam_pos.z)).Len()
layer_n = abs(
max(
0,
min(1, (d - self.distance_min) /
(self.distance_max - self.distance_min))) * 2 - 1)
self.pc.a = (1 - min(pow(layer_n, 8), 1)) * (
1 - pow(1. - scale_factor,
self.alpha_scale_falloff)) * smooth_alpha_threshold
particle[1] = hg.Matrix4(hg.Matrix3.Identity)
particle[1].SetScale(hg.Vector3(s, s, s))
particle[1].SetTranslation(pos)
material = particle[2]
material.SetFloat2("pos0", position.x, position.y)
material.SetFloat("alpha_cloud", self.pc.a)
self.renderable_system.DrawGeometry(particle[0], particle[1])
self.particle_index[id] += 1
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 GameCreateCamera():
gg.camera_angle = hg.Vector3(0.0, pi/2.0, 0.0)
gg.spawn_point = gg.scene.GetNode("spawn_point")
# camera Y controller
gg.camera_y_controller = plus.AddDummy(gg.scene)
gg.camera_y_controller.SetName("camera_y_controller")
gg.camera_y_controller.GetTransform().SetPosition(gg.spawn_point.GetTransform().GetPosition())
gg.camera_y_controller.GetTransform().SetRotation(gg.camera_angle * hg.Vector3(0.0, 1.0, 0.0))
# camera
gg.camera = plus.AddCamera(gg.scene)
gg.camera.SetName("game_camera")
gg.camera.GetTransform().SetParent(gg.camera_y_controller)
gg.camera.GetTransform().SetRotation(gg.camera_angle * hg.Vector3(1.0, 0.0, 0.0))
gg.scene.SetCurrentCamera(gg.camera)
gg.camera_target_angle = hg.Vector3(gg.camera_angle)
def update_satellite_camera(camera, screen_ratio, dts):
camera.GetTransform().SetPosition(
hg.Vector3(target_point.x,
camera.GetCamera().GetOrthographicSize() * screen_ratio,
target_point.z))
cam = camera.GetCamera()
size = cam.GetOrthographicSize()
cam.SetOrthographicSize(size + (satellite_view_size - size) *
satellite_view_size_inertia)
def reset(self): self.num_new = 0 self.particles_cnt = 0 self.particles_cnt_f = 0 self.end=False for i in range(self.num_particles): self.particles[i].age = -1 self.particles[i].node.SetEnabled(False) self.particles[i].v_move = hg.Vector3(0, 0, 0)
def update_kinetics(self, position: hg.Vector3, direction: hg.Vector3, v0: hg.Vector3, axisY: hg.Vector3, dts):
self.num_new = 0
if not self.end:
self.particles_cnt_f += dts * self.flow
self.num_new = int(self.particles_cnt_f) - self.particles_cnt
if self.num_new > 0:
for i in range(self.num_new):
if not self.loop and self.particles_cnt+i>=self.num_particles:break
particle = self.particles[(self.particles_cnt + i) % self.num_particles]
particle.age = 0
particle.delay = uniform(self.delay_range.x, self.delay_range.y)
particle.scale = uniform(self.scale_range.x,self.scale_range.y)
mat = particle.node.GetTransform()
dir = self.get_direction(direction)
rot_mat = hg.Matrix3(hg.Cross(axisY, dir), axisY, dir)
mat.SetPosition(position + dir * self.start_offset)
mat.SetRotationMatrix(rot_mat)
mat.SetScale(self.start_scale)
particle.rot_speed = hg.Vector3(uniform(self.rot_range_x.x, self.rot_range_x.y),
uniform(self.rot_range_y.x, self.rot_range_y.y),
uniform(self.rot_range_z.x, self.rot_range_z.y))
particle.v_move = v0 + dir * uniform(self.start_speed_range.x, self.start_speed_range.y)
particle.node.SetEnabled(False)
self.particles_cnt += self.num_new
n=0
for particle in self.particles:
if particle.age > particle.delay:
particle.kill()
elif particle.age == 0:
particle.age += dts
n+=1
elif particle.age > 0:
n+=1
if not particle.node.GetEnabled(): particle.node.SetEnabled(True)
t = particle.age / particle.delay
mat = particle.node.GetTransform()
pos = mat.GetPosition()
rot = mat.GetRotation()
particle.v_move += self.gravity * dts
spd = particle.v_move.Len()
particle.v_move -= particle.v_move.Normalized()*spd*self.linear_damping*dts
pos += particle.v_move * dts
rot += particle.rot_speed * dts
pos.y=max(0,pos.y)
mat.SetPosition(pos)
mat.SetRotation(rot)
mat.SetScale((self.start_scale * (1 - t) + self.end_scale * t)*particle.scale)
# material = particle.node.GetObject().GetGeometry().GetMaterial(0)
# material.SetFloat4("self_color",1.,1.,0.,1-t)
self.update_color(particle)
# particle.node.GetObject().GetGeometry().GetMaterial(0).SetFloat4("teint", 1,1,1,1)
particle.age += dts
if n==0 and not self.loop: self.end=True
def rotate_vector(cls, point: hg.Vector3, axe: hg.Vector3, angle): axe.Normalize() dot_prod = point.x * axe.x + point.y * axe.y + point.z * axe.z cos_angle = cos(angle) sin_angle = sin(angle) return hg.Vector3( cos_angle * point.x + sin_angle * (axe.y * point.z - axe.z * point.y) + (1 - cos_angle) * dot_prod * axe.x, \ cos_angle * point.y + sin_angle * (axe.z * point.x - axe.x * point.z) + (1 - cos_angle) * dot_prod * axe.y, \ cos_angle * point.z + sin_angle * (axe.x * point.y - axe.y * point.x) + (1 - cos_angle) * dot_prod * axe.z)
def update_track_direction(camera: hg.Node, dts, noise_level):
# v = target_point - camera.GetTransform().GetPosition()
f = radians(noise_level)
rot = target_matrix.ToEuler()
rot += hg.Vector3(
noise_x.temporal_Perlin_noise(dts) * f,
noise_y.temporal_Perlin_noise(dts) * f,
noise_z.temporal_Perlin_noise(dts) * f)
rot_mat = hg.Matrix3.FromEuler(rot)
rot_mat = rot_mat * track_orientation
camera.GetTransform().SetRotationMatrix(rot_mat)
return rot_mat # camera.GetTransform().GetWorld().GetRotationMatrix().LookAt(v, target_matrix.GetY()))
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 GameControlCamera(dt):
mouse_device = hg.GetInputSystem().GetDevice("mouse")
mouse_wheel = mouse_device.GetValue(hg.InputRotY)
if mouse_wheel != 0.0:
gg.camera_zoom_target += gg.zoom_speed * hg.time_to_sec_f(dt) * mouse_wheel
gg.camera_zoom_target = max(min(gg.camera_zoom_target, gg.zoom_min_max.y), gg.zoom_min_max.x)
print(gg.camera_zoom_target)
if mouse_device.IsButtonDown(hg.Button0):
gg.mouse = hg.Vector2(mouse_device.GetValue(hg.InputAxisX), mouse_device.GetValue(hg.InputAxisY))
mouse_speed = gg.prev_mouse - gg.mouse
gg.prev_mouse = hg.Vector2(gg.mouse)
# print("Mouse X: %f, Mouse Y: %f" % (mouse_speed.x, mouse_speed.y))
gg.camera_target_angle.x -= radians(mouse_speed.y * hg.time_to_sec_f(dt) * gg.camera_rot_x_speed)
gg.camera_target_angle.x = max(min(gg.camera_target_angle.x, gg.camera_rot_x_min_max.y), gg.camera_rot_x_min_max.x)
gg.camera_target_angle.y += radians(mouse_speed.x * hg.time_to_sec_f(dt) * gg.camera_rot_y_speed)
else:
gg.mouse = hg.Vector2(mouse_device.GetValue(hg.InputAxisX), mouse_device.GetValue(hg.InputAxisY))
gg.prev_mouse = hg.Vector2(gg.mouse)
cam_dt = gg.camera_target_angle - gg.camera_angle
zoom_dt = gg.camera_zoom_target - gg.camera_zoom
if gg.camera_lazyness == 0:
cam_dt *= hg.time_to_sec_f(dt)
zoom_dt *= hg.time_to_sec_f(dt)
else:
cam_dt *= hg.time_to_sec_f(dt) * (1.0 / gg.camera_lazyness)
zoom_dt *= hg.time_to_sec_f(dt) * (1.0 / gg.camera_lazyness)
gg.camera_angle += cam_dt
gg.camera.GetTransform().SetRotation(gg.camera_angle * hg.Vector3(1.0, 0.0, 0.0))
gg.camera_y_controller.GetTransform().SetRotation(gg.camera_angle * hg.Vector3(0.0, 1.0, 0.0))
gg.camera_zoom += zoom_dt
gg.camera.GetCamera().SetZoomFactor(gg.camera_zoom)
def init_scene(plus):
scene = plus.NewScene()
camera = plus.AddCamera(
scene, hg.Matrix4.TranslationMatrix(hg.Vector3(0, 0, -10)))
camera.SetName("Camera")
camera.GetCamera().SetZNear(1.)
camera.GetCamera().SetZFar(10000)
init_lights(plus, scene)
fps = hg.FPSController(0, 500, -10)
while not scene.IsReady(): # Wait until scene is ready
plus.UpdateScene(scene, plus.UpdateClock())
plus.UpdateScene(scene, plus.UpdateClock())
return scene, fps
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
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)
