def wireframe_json_to_segment_list(filename=None): segment_list = [] if filename is not None and hg.GetFilesystem().Exists(filename): with open(hg.GetFilesystem().MapToAbsolute(filename), 'r') as fp: data = json.load(fp) # print(data) for _object in data: _object_dict = data[_object]['object'] _object_name = _object_dict['object_name'] print('Found an object, named \'%s\'' % _object_name) for _segment in _object_dict['segments']: for _vertex_as_array in _segment: # print(_vertex_as_array) segment_list.append(_vertex_as_array) # _vertex = Vector3() if len(_object_dict['segments']) > 0: segment_list.append(_object_dict['segments'][-1]) print("found total " + str(len(segment_list)) + " segment(s).") return segment_list
def save_json_script( self, scene, output_filename="assets/scripts/clouds_parameters.json"): script_parameters = self.__getstate__() json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def load_parameters(self, file_name="assets/scripts/water_reflection.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) self.color = list_to_color(script_parameters["color"]) self.reflect_level = script_parameters["reflect_level"]
def get_sprite_seq_max_frame(filename_base, file_extension=".png"): n = 0 while hg.GetFilesystem().Exists("@assets/" + filename_base + str(n) + file_extension): n += 1 return n
def save_json_matrix(pos: hg.Vector3, rot: hg.Vector3, output_filename): script_parameters = { "position": vec3_to_list(pos), "rotation": vec3_to_list_degrees(rot) } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def load_json_script(self, file_name="assets/scripts/sea_parameters.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) self.horizon_N_color = list_to_color( script_parameters["horizon_N_color"]) self.horizon_S_color = list_to_color( script_parameters["horizon_S_color"]) self.zenith_color = list_to_color( script_parameters["zenith_color"]) self.zenith_falloff = script_parameters["zenith_falloff"] self.tex_sky_N_intensity = script_parameters["tex_sky_N_intensity"] self.horizon_line_color = list_to_color( script_parameters["horizon_line_color"]) self.sea_color = list_to_color(script_parameters["sea_color"]) self.sea_scale = list_to_vec3(script_parameters["sea_scale"]) self.sea_reflection = script_parameters["sea_reflection"] self.horizon_line_size = script_parameters["horizon_line_size"] self.sea_filtering = script_parameters["sea_filtering"] self.max_filter_samples = script_parameters["max_filter_samples"] self.filter_precision = script_parameters["filter_precision"] self.clouds_scale = list_to_vec3(script_parameters["clouds_scale"]) self.clouds_altitude = script_parameters["clouds_altitude"] self.clouds_absorption = script_parameters["clouds_absorption"] self.reflect_offset = script_parameters["reflect_offset"] self.render_scene_reflection = script_parameters[ "render_scene_reflection"]
def load_json_matrix(file_name): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) pos = list_to_vec3(script_parameters["position"]) rot = list_to_vec3_radians(script_parameters["rotation"]) return pos, rot return None, None
def save_parameters(self, output_filename="assets/scripts/water_reflection.json" ): script_parameters = { "color": color_to_list(self.color), "reflect_level": self.reflect_level } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def load_parameters(self, file_name="assets/scripts/post_render.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) self.contrast = script_parameters["contrast"] self.contrast_threshold = script_parameters["contrast_threshold"] self.hue = script_parameters["hue"] self.saturation = script_parameters["saturation"] self.value = script_parameters["value"]
def save_scene_parameters(output_filename="assets/scripts/scene_parameters.json"): environment = Main.scene.GetEnvironment() script_parameters = {"sunlight_color": color_to_list(Main.ligth_sun.GetLight().GetDiffuseColor()), "skylight_color": color_to_list(Main.ligth_sky.GetLight().GetDiffuseColor()), "ambient_color": color_to_list(environment.GetAmbientColor()), "ambient_intensity": environment.GetAmbientIntensity(), "render_clouds": Main.render_volumetric_clouds } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
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 load_scene_parameters(file_name="assets/scripts/scene_parameters.json"): json_script = hg.GetFilesystem().FileToString(file_name) environment = Main.scene.GetEnvironment() if json_script != "": script_parameters = json.loads(json_script) Main.ligth_sun.GetLight().SetDiffuseColor(list_to_color(script_parameters["sunlight_color"])) Main.ligth_sky.GetLight().SetDiffuseColor(list_to_color(script_parameters["skylight_color"])) environment.SetAmbientColor(list_to_color(script_parameters["ambient_color"])) environment.SetAmbientIntensity(script_parameters["ambient_intensity"]) Main.render_volumetric_clouds = script_parameters["render_clouds"]
def load_game_parameters(file_name="assets/scripts/dogfight.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) set_p1_missiles_smoke_color(list_to_color(script_parameters["p1_missiles_smoke_color"])) set_p2_missiles_smoke_color(list_to_color(script_parameters["p2_missiles_smoke_color"])) set_p1_gun_color(list_to_color(script_parameters["p1_gun_color"])) set_p2_gun_color(list_to_color(script_parameters["p2_gun_color"])) Main.radial_blur_strength=script_parameters["radial_blur_strength"] Main.deceleration_blur_strength=script_parameters["deceleration_blur_strength"] Main.acceleration_blur_strength=script_parameters["acceleration_blur_strength"]
def save_game_parameters(output_filename="assets/scripts/dogfight.json"): script_parameters = {"p1_missiles_smoke_color": color_to_list(Main.p1_missiles_smoke_color), "p2_missiles_smoke_color": color_to_list(Main.p2_missiles_smoke_color), "p1_gun_color": color_to_list(Main.bullets.colors[0]), "p2_gun_color": color_to_list(Main.ennemy_bullets.colors[0]), "radial_blur_strength": Main.radial_blur_strength, "deceleration_blur_strength": Main.deceleration_blur_strength, "acceleration_blur_strength": Main.acceleration_blur_strength } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def save_parameters(self, output_filename="assets/scripts/post_render.json"): script_parameters = { "contrast": self.contrast, "contrast_threshold": self.contrast_threshold, "hue": self.hue, "saturation": self.saturation, "value": self.value } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def post_processes_save_parameters(output_filename="assets/scripts/post_render.json"): script_parameters = {"hue": Main.HSL_postProcess.GetH(), "saturation": Main.HSL_postProcess.GetS(), "value":Main.HSL_postProcess.GetL(), "flag_MotionBlur":Main.flag_MotionBlur, "mb_blur_radius":Main.MotionBlur_postProcess.GetBlurRadius(), "mb_exposure":Main.MotionBlur_postProcess.GetExposure(), "mb_sample_count":Main.MotionBlur_postProcess.GetSampleCount() } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def save_json_matrix(pos: hg.Vector3, rot: hg.Vector3, output_filename="assets/scripts/camera_positions.json"): script_parameters = { "x": pos.x, "y": pos.y, "z": pos.z, "rot_x": rot.x, "rot_y": rot.y, "rot_z": rot.z } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
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 post_processes_load_parameters(file_name="assets/scripts/post_render.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) Main.HSL_postProcess.SetH(script_parameters["hue"]) Main.HSL_postProcess.SetS(script_parameters["saturation"]) Main.HSL_postProcess.SetL(script_parameters["value"]) Main.flag_MotionBlur=script_parameters["flag_MotionBlur"] Main.MotionBlur_postProcess.SetBlurRadius(script_parameters["mb_blur_radius"]) Main.MotionBlur_postProcess.SetExposure(script_parameters["mb_exposure"]) Main.MotionBlur_postProcess.SetSampleCount(int(script_parameters["mb_sample_count"])) Main.camera.RemoveComponent(Main.MotionBlur_postProcess) if Main.flag_MotionBlur: Main.camera.AddComponent(Main.MotionBlur_postProcess)
def save_json_script( self, output_filename="assets/scripts/terrain_parameters.json"): script_parameters = { "map1_scale_x": self.facteur_echelle_terrain_l1.x, "map1_scale_y": self.facteur_echelle_terrain_l1.y, "map2_scale_x": self.facteur_echelle_terrain_l2.x, "map2_scale_y": self.facteur_echelle_terrain_l2.y, "map3_scale_x": self.facteur_echelle_terrain_l3.x, "map3_scale_y": self.facteur_echelle_terrain_l3.y, "map1_amplitude": self.amplitude_l1, "map2_amplitude": self.amplitude_l2, "map3_amplitude": self.amplitude_l3, "distance_factor": self.facteur_precision_distance, "water_altitude": self.altitude_eau, "water_reflexion": self.reflexion_eau, "offset_x": self.offset_terrain.x, "offset_y": self.offset_terrain.y, "offset_z": self.offset_terrain.z } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
def load_json_script(self, file_name="assets/scripts/terrain_parameters.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) self.facteur_echelle_terrain_l1 = hg.Vector2( script_parameters["map1_scale_x"], script_parameters["map1_scale_y"]) self.facteur_echelle_terrain_l2 = hg.Vector2( script_parameters["map2_scale_x"], script_parameters["map2_scale_y"]) self.facteur_echelle_terrain_l3 = hg.Vector2( script_parameters["map3_scale_x"], script_parameters["map3_scale_y"]) self.amplitude_l1 = script_parameters["map1_amplitude"] self.amplitude_l2 = script_parameters["map2_amplitude"] self.amplitude_l3 = script_parameters["map3_amplitude"] self.facteur_precision_distance = script_parameters[ "distance_factor"] self.altitude_eau = script_parameters["water_altitude"] self.reflexion_eau = script_parameters["water_reflexion"] self.offset_terrain.x = script_parameters["offset_x"] self.offset_terrain.y = script_parameters["offset_y"] self.offset_terrain.z = script_parameters["offset_z"]
def save_json_script(self, output_filename="assets/scripts/sea_parameters.json"): script_parameters = { "horizon_N_color": color_to_list(self.horizon_N_color), "horizon_S_color": color_to_list(self.horizon_S_color), "horizon_line_color": color_to_list(self.horizon_line_color), "zenith_color": color_to_list(self.zenith_color), "zenith_falloff": self.zenith_falloff, "tex_sky_N_intensity": self.tex_sky_N_intensity, "sea_color": color_to_list(self.sea_color), "sea_reflection": self.sea_reflection, "horizon_line_size": self.horizon_line_size, "sea_scale": vec3_to_list(self.sea_scale), "sea_filtering": self.sea_filtering, "max_filter_samples": self.max_filter_samples, "filter_precision": self.filter_precision, "clouds_scale": vec3_to_list(self.clouds_scale), "clouds_altitude": self.clouds_altitude, "clouds_absorption": self.clouds_absorption, "reflect_offset": self.reflect_offset, "render_scene_reflection": self.render_scene_reflection } json_script = json.dumps(script_parameters, indent=4) return hg.GetFilesystem().StringToFile(output_filename, json_script)
import os import harfang as hg # mount a standard file system as the 'std:' prefix hg.MountFileDriver(hg.StdFileDriver(), "std:") # mount a standard file system pointing to the current directory as the 'cwd:' prefix hg.MountFileDriver(hg.StdFileDriver(os.path.dirname(__file__)), "cwd:") # get the full path to this file this_file_path = os.path.realpath(__file__) # get this file name (ie. path relative to the current directory) this_file_name = os.path.basename(__file__) # the engine can access it relative to the current directory through the 'cwd:' mount point cwd_path = "cwd:" + this_file_name res_cwd_access = hg.GetFilesystem().Exists(cwd_path) # and it can access it using its absolute path through the std: mount point std_path = "std:" + this_file_path res_std_access = hg.GetFilesystem().Exists(std_path) # however, when no prefix is specified the engine has no way to access it from its absolute path res_direct_access = hg.GetFilesystem().Exists(this_file_path) print("Can access '%s' (expect KO): %s" % (this_file_path, str(res_direct_access))) print("Can access '%s' (expect OK): %s" % (cwd_path, str(res_cwd_access))) print("Can access '%s' (expect OK): %s" % (std_path, str(res_std_access)))
# Access to the file system import os import harfang as hg # mount the system file driver, StdFileDriver wraps the system native file API hg.MountFileDriver(hg.StdFileDriver()) # test that we indeed have access to the file system path = os.path.realpath( __file__) # absolute path to this file on the file system result = hg.GetFilesystem().Exists(path) # can the engine file system see it? print("Access OK: %s" % str(result))
# Convert from any supported audio file format to a PCM file import harfang as hg import os hg.LoadPlugins() hg.MountFileDriver(hg.StdFileDriver()) # open input file as an audio data source src = hg.GetAudioIO().Open('_data/skaven.it') # open output file out = hg.GetFilesystem().Open('skaven.pcm', hg.FileWrite) pcm = hg.BinaryData() while src.GetState() != hg.AudioDataEnded: # get PCM frame to the binary blob size, timestamp = src.GetFrame(pcm) # output PCM frame to the file handle out.Write(pcm) # reset the binary blob, do not free storage pcm.Reset() # - or - extract all PCM data to a huge binary blob and save it to file (consumes much more memory) """ # extract all PCM data from the source as a binary blob sze = hg.ExtractAudioData(src, pcm) # save the complete PCM binary blob to a file
# Access to a file inside a Zip archive import harfang as hg archive_path = "_data/hello.zip" # mount a std file driver to access the archive hg.MountFileDriver(hg.StdFileDriver()) # mount a Zip file driver connected to the archive on the prefix "zip:" file = hg.GetFilesystem().Open(archive_path, hg.FileRead) hg.MountFileDriver(hg.ZipFileDriver(file), "zip:") # assert that we can find a file named "hello.txt" on the "zip:" prefix # ie. inside the archive connected to the ZipFileDriver "zip:" resolves to res = hg.GetFilesystem().Exists("zip:hello.txt") print("Can access 'hello.txt' (expect OK): %s" % str(res))
# Sand-boxed access to the file system import os import harfang as hg # mount two std file driver under two different prefixes, only one acts as a sandbox hg.MountFileDriver(hg.StdFileDriver(os.path.dirname(__file__)), "std:") hg.MountFileDriver(hg.StdFileDriver(os.path.dirname(__file__), True), "box:") # access the readme.txt file outside of the std file driver root directory: std_path = "std:../_data/owl.jpg" res_std_access = hg.GetFilesystem().Exists(std_path) # do the same on the sandboxed box: mount point box_path = "box:../_data/owl.jpg" res_box_access = hg.GetFilesystem().Exists(box_path) print("Can access '%s' (expect OK): %s" % (std_path, str(res_std_access))) print("Can access '%s' (expect KO): %s" % (box_path, str(res_box_access)))
def load_json_script(self, file_name="assets/scripts/clouds_parameters.json"): json_script = hg.GetFilesystem().FileToString(file_name) if json_script != "": script_parameters = json.loads(json_script) self.__setstate__(script_parameters)