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)