├── .editorconfig ├── .gitattributes ├── .gitignore ├── EngineConfig.ini ├── LICENSE ├── PathosEngine.sln ├── README.md ├── Setup.ps1 ├── projects ├── App_RhythmGame │ ├── App_RhythmGame.vcxproj │ ├── App_RhythmGame.vcxproj.filters │ └── src │ │ ├── bass_wrapper.cpp │ │ ├── bass_wrapper.h │ │ ├── main.cpp │ │ ├── music_database.cpp │ │ ├── music_database.h │ │ ├── music_record.cpp │ │ ├── music_record.h │ │ ├── world_rhythm_game.cpp │ │ └── world_rhythm_game.h ├── Engine.props ├── PathosEngine │ ├── PathosEngine.vcxproj │ ├── PathosEngine.vcxproj.filters │ └── src │ │ ├── badger │ │ ├── assertion │ │ │ ├── assertion.cpp │ │ │ └── assertion.h │ │ ├── math │ │ │ ├── aabb.h │ │ │ ├── bits.h │ │ │ ├── constants.h │ │ │ ├── convex_hull.cpp │ │ │ ├── convex_hull.h │ │ │ ├── hit_test.h │ │ │ ├── minmax.h │ │ │ ├── plane.h │ │ │ ├── random.cpp │ │ │ ├── random.h │ │ │ ├── rotator.cpp │ │ │ ├── rotator.h │ │ │ ├── signed_volume.cpp │ │ │ ├── signed_volume.h │ │ │ ├── spline.cpp │ │ │ ├── spline.h │ │ │ └── vector_math.h │ │ ├── physics │ │ │ ├── collision.cpp │ │ │ ├── collision.h │ │ │ ├── physics_scene.cpp │ │ │ ├── physics_scene.h │ │ │ ├── shape.cpp │ │ │ └── shape.h │ │ ├── system │ │ │ ├── cpu.cpp │ │ │ ├── cpu.h │ │ │ ├── mem_alloc.cpp │ │ │ ├── mem_alloc.h │ │ │ ├── platform.h │ │ │ ├── stopwatch.h │ │ │ ├── thread_pool.cpp │ │ │ └── thread_pool.h │ │ └── types │ │ │ ├── enum.h │ │ │ ├── half_float.h │ │ │ ├── int_types.h │ │ │ ├── matrix_types.h │ │ │ ├── noncopyable.h │ │ │ ├── string_hash.h │ │ │ └── vector_types.h │ │ ├── pathos │ │ ├── console.cpp │ │ ├── console.h │ │ ├── core_minimal.h │ │ ├── debug_overlay.cpp │ │ ├── debug_overlay.h │ │ ├── engine.cpp │ │ ├── engine.h │ │ ├── engine_policy.cpp │ │ ├── engine_policy.h │ │ ├── engine_version.h │ │ ├── gui │ │ │ ├── gui_window.cpp │ │ │ └── gui_window.h │ │ ├── input │ │ │ ├── input_constants.h │ │ │ ├── input_manager.cpp │ │ │ ├── input_manager.h │ │ │ ├── input_system.cpp │ │ │ ├── input_system.h │ │ │ ├── xinput_manager.cpp │ │ │ └── xinput_manager.h │ │ ├── loader │ │ │ ├── asset_streamer.cpp │ │ │ ├── asset_streamer.h │ │ │ ├── gltf_loader.cpp │ │ │ ├── gltf_loader.h │ │ │ ├── image_loader.cpp │ │ │ ├── image_loader.h │ │ │ ├── objloader.cpp │ │ │ ├── objloader.h │ │ │ ├── scene_desc_parser.cpp │ │ │ ├── scene_desc_parser.h │ │ │ ├── scene_loader.cpp │ │ │ ├── scene_loader.h │ │ │ ├── spline_loader.cpp │ │ │ └── spline_loader.h │ │ ├── material │ │ │ ├── material.cpp │ │ │ ├── material.h │ │ │ ├── material_id.h │ │ │ ├── material_parameter.h │ │ │ ├── material_proxy.cpp │ │ │ ├── material_proxy.h │ │ │ ├── material_shader.cpp │ │ │ ├── material_shader.h │ │ │ ├── material_shader_assembler.cpp │ │ │ └── material_shader_assembler.h │ │ ├── mesh │ │ │ ├── geometry.cpp │ │ │ ├── geometry.h │ │ │ ├── geometry_primitive.cpp │ │ │ ├── geometry_primitive.h │ │ │ ├── geometry_procedural.h │ │ │ ├── model_transform.cpp │ │ │ ├── model_transform.h │ │ │ ├── static_mesh.cpp │ │ │ └── static_mesh.h │ │ ├── overlay │ │ │ ├── brush.cpp │ │ │ ├── brush.h │ │ │ ├── button.cpp │ │ │ ├── button.h │ │ │ ├── display_object.cpp │ │ │ ├── display_object.h │ │ │ ├── display_object_proxy.cpp │ │ │ ├── display_object_proxy.h │ │ │ ├── label.cpp │ │ │ ├── label.h │ │ │ ├── rectangle.cpp │ │ │ └── rectangle.h │ │ ├── render │ │ │ ├── auto_exposure.cpp │ │ │ ├── auto_exposure.h │ │ │ ├── depth_prepass.cpp │ │ │ ├── depth_prepass.h │ │ │ ├── direct_lighting.cpp │ │ │ ├── direct_lighting.h │ │ │ ├── forward │ │ │ │ ├── translucency_rendering.cpp │ │ │ │ └── translucency_rendering.h │ │ │ ├── fullscreen_util.cpp │ │ │ ├── fullscreen_util.h │ │ │ ├── gbuffer_pass.cpp │ │ │ ├── gbuffer_pass.h │ │ │ ├── god_ray.cpp │ │ │ ├── god_ray.h │ │ │ ├── image_based_lighting.cpp │ │ │ ├── image_based_lighting.h │ │ │ ├── indirect_lighting.cpp │ │ │ ├── indirect_lighting.h │ │ │ ├── landscape_rendering.cpp │ │ │ ├── landscape_rendering.h │ │ │ ├── light_probe_baker.cpp │ │ │ ├── light_probe_baker.h │ │ │ ├── overlay │ │ │ │ ├── overlaypass.h │ │ │ │ ├── overlaypass_base.cpp │ │ │ │ ├── overlaypass_base.h │ │ │ │ ├── overlaypass_image.cpp │ │ │ │ ├── overlaypass_image.h │ │ │ │ ├── overlaypass_standard.cpp │ │ │ │ ├── overlaypass_standard.h │ │ │ │ ├── overlaypass_text.cpp │ │ │ │ └── overlaypass_text.h │ │ │ ├── postprocessing │ │ │ │ ├── anti_aliasing.cpp │ │ │ │ ├── anti_aliasing.h │ │ │ │ ├── anti_aliasing_fxaa.cpp │ │ │ │ ├── anti_aliasing_fxaa.h │ │ │ │ ├── anti_aliasing_taa.cpp │ │ │ │ ├── anti_aliasing_taa.h │ │ │ │ ├── bloom.cpp │ │ │ │ ├── bloom.h │ │ │ │ ├── bloom_setup.cpp │ │ │ │ ├── bloom_setup.h │ │ │ │ ├── depth_of_field.cpp │ │ │ │ ├── depth_of_field.h │ │ │ │ ├── post_process.cpp │ │ │ │ ├── post_process.h │ │ │ │ ├── ssao.cpp │ │ │ │ ├── ssao.h │ │ │ │ ├── super_res.cpp │ │ │ │ ├── super_res.h │ │ │ │ ├── super_res_fsr1.cpp │ │ │ │ ├── super_res_fsr1.h │ │ │ │ ├── tone_mapping.cpp │ │ │ │ └── tone_mapping.h │ │ │ ├── render_overlay.cpp │ │ │ ├── render_overlay.h │ │ │ ├── render_target.cpp │ │ │ ├── render_target.h │ │ │ ├── renderer.h │ │ │ ├── resolve_unlit.cpp │ │ │ ├── resolve_unlit.h │ │ │ ├── scene_proxy.cpp │ │ │ ├── scene_proxy.h │ │ │ ├── scene_proxy_common.h │ │ │ ├── scene_render_targets.cpp │ │ │ ├── scene_render_targets.h │ │ │ ├── scene_renderer.cpp │ │ │ ├── scene_renderer.h │ │ │ ├── screen_space_reflection.cpp │ │ │ ├── screen_space_reflection.h │ │ │ ├── shadow_directional.cpp │ │ │ ├── shadow_directional.h │ │ │ ├── shadow_omni.cpp │ │ │ ├── shadow_omni.h │ │ │ ├── sky_atmosphere.cpp │ │ │ ├── sky_atmosphere.h │ │ │ ├── sky_panorama.cpp │ │ │ ├── sky_panorama.h │ │ │ ├── skybox.cpp │ │ │ ├── skybox.h │ │ │ ├── visualize_buffer.cpp │ │ │ ├── visualize_buffer.h │ │ │ ├── visualize_indirect_diffuse.cpp │ │ │ ├── visualize_indirect_diffuse.h │ │ │ ├── visualize_light_probe.cpp │ │ │ ├── visualize_light_probe.h │ │ │ ├── volumetric_clouds.cpp │ │ │ └── volumetric_clouds.h │ │ ├── render_minimal.h │ │ ├── render_thread.cpp │ │ ├── render_thread.h │ │ ├── rhi │ │ │ ├── buffer.cpp │ │ │ ├── buffer.h │ │ │ ├── gl_context_manager.cpp │ │ │ ├── gl_context_manager.h │ │ │ ├── gl_debug_group.cpp │ │ │ ├── gl_debug_group.h │ │ │ ├── gl_handles.h │ │ │ ├── gl_live_objects.cpp │ │ │ ├── gl_live_objects.h │ │ │ ├── indirect_draw.h │ │ │ ├── render_command_list.cpp │ │ │ ├── render_command_list.generated.h │ │ │ ├── render_command_list.h │ │ │ ├── render_commands.generated.h │ │ │ ├── render_commands.h │ │ │ ├── render_device.cpp │ │ │ ├── render_device.h │ │ │ ├── sampler.cpp │ │ │ ├── sampler.h │ │ │ ├── shader_program.cpp │ │ │ ├── shader_program.h │ │ │ ├── texture.cpp │ │ │ ├── texture.h │ │ │ └── uniform_buffer.h │ │ ├── scene │ │ │ ├── actor.cpp │ │ │ ├── actor.h │ │ │ ├── actor_component.cpp │ │ │ ├── actor_component.h │ │ │ ├── camera.cpp │ │ │ ├── camera.h │ │ │ ├── directional_light_actor.h │ │ │ ├── directional_light_component.cpp │ │ │ ├── directional_light_component.h │ │ │ ├── irradiance_volume_actor.cpp │ │ │ ├── irradiance_volume_actor.h │ │ │ ├── landscape_actor.cpp │ │ │ ├── landscape_actor.h │ │ │ ├── landscape_component.cpp │ │ │ ├── landscape_component.h │ │ │ ├── physics_component.cpp │ │ │ ├── physics_component.h │ │ │ ├── point_light_actor.h │ │ │ ├── point_light_component.h │ │ │ ├── rect_light_actor.h │ │ │ ├── rect_light_component.h │ │ │ ├── reflection_probe_actor.cpp │ │ │ ├── reflection_probe_actor.h │ │ │ ├── reflection_probe_component.cpp │ │ │ ├── reflection_probe_component.h │ │ │ ├── scene.cpp │ │ │ ├── scene.h │ │ │ ├── scene_capture_component.cpp │ │ │ ├── scene_capture_component.h │ │ │ ├── scene_component.cpp │ │ │ ├── scene_component.h │ │ │ ├── scene_render_settings.h │ │ │ ├── sky_actor.h │ │ │ ├── sky_atmosphere_actor.h │ │ │ ├── sky_atmosphere_component.h │ │ │ ├── sky_common.cpp │ │ │ ├── sky_common.h │ │ │ ├── sky_panorama_actor.h │ │ │ ├── sky_panorama_component.cpp │ │ │ ├── sky_panorama_component.h │ │ │ ├── skybox_actor.cpp │ │ │ ├── skybox_actor.h │ │ │ ├── skybox_component.cpp │ │ │ ├── skybox_component.h │ │ │ ├── static_mesh_actor.h │ │ │ ├── static_mesh_component.cpp │ │ │ ├── static_mesh_component.h │ │ │ ├── volumetric_cloud_actor.h │ │ │ ├── volumetric_cloud_component.h │ │ │ ├── world.cpp │ │ │ └── world.h │ │ ├── smart_pointer.h │ │ ├── text │ │ │ ├── font_mgr.cpp │ │ │ ├── font_mgr.h │ │ │ ├── font_texture_cache.cpp │ │ │ ├── font_texture_cache.h │ │ │ ├── text_actor.cpp │ │ │ ├── text_actor.h │ │ │ ├── text_component.cpp │ │ │ ├── text_component.h │ │ │ ├── text_geometry.cpp │ │ │ └── text_geometry.h │ │ └── util │ │ │ ├── color_conversion.h │ │ │ ├── cpu_profiler.cpp │ │ │ ├── cpu_profiler.h │ │ │ ├── engine_thread.cpp │ │ │ ├── engine_thread.h │ │ │ ├── engine_util.cpp │ │ │ ├── engine_util.h │ │ │ ├── file_system.cpp │ │ │ ├── file_system.h │ │ │ ├── image_data.h │ │ │ ├── log.cpp │ │ │ ├── log.h │ │ │ ├── malloc_emulator.cpp │ │ │ ├── malloc_emulator.h │ │ │ ├── os_util.cpp │ │ │ ├── os_util.h │ │ │ ├── renderdoc_integration.cpp │ │ │ ├── renderdoc_integration.h │ │ │ ├── resource_finder.cpp │ │ │ ├── resource_finder.h │ │ │ ├── string_conversion.cpp │ │ │ ├── string_conversion.h │ │ │ ├── sync_event.cpp │ │ │ ├── sync_event.h │ │ │ ├── transform_helper.cpp │ │ │ └── transform_helper.h │ │ ├── pch.cpp │ │ ├── pch.h │ │ └── thirdparty │ │ ├── gl3w.c │ │ ├── tinygltf.cpp │ │ └── tinyobjloader.cpp ├── TestProject.props ├── Test_DeferredRenderer │ ├── Test_DeferredRenderer.vcxproj │ ├── Test_DeferredRenderer.vcxproj.filters │ └── src │ │ ├── csm_debugger.cpp │ │ ├── csm_debugger.h │ │ ├── galaxy_gen.cpp │ │ ├── galaxy_gen.h │ │ ├── lightning_effect.cpp │ │ ├── lightning_effect.h │ │ ├── main.cpp │ │ ├── player_controller.cpp │ │ ├── player_controller.h │ │ ├── transform_test_actor.cpp │ │ ├── transform_test_actor.h │ │ ├── world1.cpp │ │ ├── world1.h │ │ ├── world_lightroom.cpp │ │ ├── world_lightroom.h │ │ ├── world_lightroom_old.cpp │ │ ├── world_lightroom_old.h │ │ ├── world_physics.cpp │ │ ├── world_physics.h │ │ ├── world_rc1.cpp │ │ ├── world_rc1.h │ │ ├── world_rc2.cpp │ │ └── world_rc2.h ├── Test_ModelViewer │ ├── Test_ModelViewer.vcxproj │ ├── Test_ModelViewer.vcxproj.filters │ └── src │ │ ├── main_modelviewer.cpp │ │ ├── player_controller.cpp │ │ ├── player_controller.h │ │ ├── world_modelviewer.cpp │ │ └── world_modelviewer.h ├── Test_Physics │ ├── Test_Physics.vcxproj │ ├── Test_Physics.vcxproj.filters │ └── src │ │ ├── main.cpp │ │ ├── player_controller.cpp │ │ ├── player_controller.h │ │ ├── world_gjk.cpp │ │ └── world_gjk.h ├── Test_RacingGame │ ├── Test_RacingGame.vcxproj │ ├── Test_RacingGame.vcxproj.filters │ └── src │ │ ├── main_racing_game.cpp │ │ ├── pathos_forward_decl.h │ │ ├── player_controller.cpp │ │ ├── player_controller.h │ │ ├── widget │ │ ├── base_widget.cpp │ │ ├── base_widget.h │ │ ├── game_options_widget.cpp │ │ ├── game_options_widget.h │ │ ├── title_widget.cpp │ │ └── title_widget.h │ │ └── world │ │ ├── world_racing_game.cpp │ │ ├── world_racing_game.h │ │ ├── world_racing_title.cpp │ │ └── world_racing_title.h ├── Test_SkeletalAnimation │ ├── Test_SkeletalAnimation.vcxproj │ ├── Test_SkeletalAnimation.vcxproj.filters │ └── src │ │ ├── animation.h │ │ ├── bone.h │ │ ├── daeloader.cpp │ │ ├── daeloader.h │ │ ├── main.cpp │ │ ├── player_controller.cpp │ │ ├── player_controller.h │ │ ├── skinned_mesh.cpp │ │ ├── skinned_mesh.h │ │ ├── world2.cpp │ │ └── world2.h └── UnitTest │ ├── TestCamera.cpp │ ├── TestExecutable.cpp │ ├── TestIrradianceMap.cpp │ ├── TestMaterialShader.cpp │ ├── TestSignedVolume.cpp │ ├── TestTransform.cpp │ ├── UnitTest.vcxproj │ ├── UnitTest.vcxproj.filters │ ├── pch.cpp │ └── pch.h ├── resources ├── common │ ├── noiseErosion.tga │ ├── noiseErosionPacked.tga │ ├── noiseShape.tga │ └── noiseShapePacked.tga ├── fonts │ ├── BMJUA.ttf │ ├── consola.ttf │ ├── consolab.ttf │ ├── consolai.ttf │ └── consolaz.ttf ├── lightroom │ ├── LightRoom.bin │ └── LightRoom.gltf ├── models │ └── animtest │ │ ├── animtest.blend │ │ ├── animtest.blend1 │ │ └── animtest.dae ├── racing_game │ ├── korea_albedo.png │ ├── korea_height.png │ ├── korea_normal.png │ ├── landscape.jpg │ ├── test_scene.json │ └── title_scene.json ├── references.txt ├── render_challenge_1 │ ├── A_Brick.png │ ├── A_Tower.png │ ├── M_Brick.png │ ├── M_Tower.png │ ├── N_Brick.png │ ├── N_Tower.png │ ├── R_Brick.png │ ├── R_Tower.png │ ├── SpaceshipCurve1.spline │ ├── SpaceshipCurve2.spline │ ├── T_Brick.png │ ├── T_Tower.png │ ├── WeatherMap.png │ ├── lightning_mask.jpg │ ├── lightning_warp.jpg │ ├── medieval_tower.mtl │ ├── medieval_tower.obj │ ├── spaceship.mtl │ └── spaceship.obj ├── rhythm_game │ ├── catch_effect_0.png │ ├── catch_effect_1.png │ ├── catch_effect_2.png │ ├── catch_effect_3.png │ ├── catch_effect_4.png │ ├── music_database.txt │ ├── note_blue.png │ ├── note_yellow.png │ ├── press_effect.png │ ├── record_imperial_march.txt │ └── record_star_wars.txt ├── skybox │ ├── HDRI │ │ ├── Ridgecrest_Road.ibl │ │ ├── Ridgecrest_Road_4k_Bg.jpg │ │ ├── Ridgecrest_Road_Env.hdr │ │ ├── Ridgecrest_Road_Ref.hdr │ │ ├── Ridgecrest_Road_Thumb.jpg │ │ └── Ridgecrest_Road_preview.jpg │ ├── ansel │ │ ├── dishonored.jpg │ │ └── the_surge.jpg │ ├── cubemap1 │ │ ├── neg_x.jpg │ │ ├── neg_y.jpg │ │ ├── neg_z.jpg │ │ ├── pos_x.jpg │ │ ├── pos_y.jpg │ │ ├── pos_z.jpg │ │ └── readme.txt │ └── placeholder │ │ ├── cubemap_back.jpg │ │ ├── cubemap_bottom.jpg │ │ ├── cubemap_front.jpg │ │ ├── cubemap_left.jpg │ │ ├── cubemap_right.jpg │ │ └── cubemap_top.jpg └── textures │ ├── 154.JPG │ ├── 154_norm.JPG │ └── pbr_sandstone │ ├── About these PBR files.txt │ ├── sandstonecliff-albedo.png │ ├── sandstonecliff-ao.png │ ├── sandstonecliff-height.png │ ├── sandstonecliff-metalness.png │ ├── sandstonecliff-normal-ue.png │ ├── sandstonecliff-preview2.jpg │ └── sandstonecliff-roughness.png ├── shaders ├── Shaders.vcxproj ├── Shaders.vcxproj.filters ├── clear_texture.glsl ├── copy_texture.fs.glsl ├── core │ ├── brdf.glsl │ ├── common.glsl │ ├── diffuse_sh.glsl │ ├── image_based_lighting.glsl │ ├── indirect_draw.glsl │ ├── light.glsl │ └── transform.glsl ├── debugging │ ├── visualize_buffer.glsl │ ├── visualize_indirect_diffuse.glsl │ └── visualize_light_probe.glsl ├── deferred_common.glsl ├── deferred_common_fs.glsl ├── direct_lighting.glsl ├── equirectangular_to_cube.glsl ├── fsr1 │ ├── ffx_a.h │ ├── ffx_fsr1.h │ ├── fsr1_wrapper_common.glsl │ ├── fsr1_wrapper_easu.glsl │ └── fsr1_wrapper_rcas.glsl ├── fullscreen_quad.glsl ├── fxaa │ └── nvidia_fxaa.glsl ├── geom_common.glsl ├── gi │ ├── brdf_integration_map.glsl │ ├── compute_diffuse_sh.glsl │ ├── deprecated_diffuse_irradiance.glsl │ ├── deprecated_specular_ibl.glsl │ ├── indirect_diffuse_lighting.glsl │ ├── indirect_specular_lighting.glsl │ ├── octahedral_depth_atlas.glsl │ ├── reflection_probe_coeffs_const_32.glsl │ ├── reflection_probe_downsample.glsl │ └── reflection_probe_filtering.glsl ├── godray │ ├── god_ray_fs.glsl │ ├── god_ray_post.glsl │ ├── god_ray_silhouette.glsl │ └── two_pass_gaussian_blur.glsl ├── hierarchical_z_buffer.glsl ├── landscape_indirect_draw.glsl ├── materials │ ├── _template.glsl │ ├── gltf_opaque.glsl │ ├── guard_tower.glsl │ ├── indirect_draw_dummy.glsl │ ├── landscape.glsl │ ├── lightning_bolt.glsl │ ├── pbr_texture.glsl │ ├── skybox_rc2.glsl │ ├── solid_color.glsl │ ├── texture_viewer.glsl │ ├── translucent_color.glsl │ ├── unlit.glsl │ └── unlit_text.glsl ├── omni_shadow_map.glsl ├── overlay │ ├── overlay_image.glsl │ ├── overlay_standard.glsl │ └── overlay_text.glsl ├── postprocess │ ├── auto_exposure_histogram_avg.glsl │ ├── auto_exposure_histogram_gen.glsl │ ├── auto_exposure_scene_avg.glsl │ ├── bloom_downsample.glsl │ ├── bloom_setup.glsl │ ├── bloom_upsample.glsl │ ├── depth_of_field.glsl │ ├── dof_prefix_sum.glsl │ ├── fxaa_wrapper.glsl │ ├── temporal_anti_aliasing.glsl │ └── tone_mapping.glsl ├── resolve_unlit.glsl ├── shadow_mapping.glsl ├── sky │ ├── atmosphere.glsl │ ├── atmosphere_precompute.glsl │ ├── blit_cubemap.glsl │ ├── copy_cubemap.glsl │ ├── sky_panorama.glsl │ ├── skybox.glsl │ ├── starfield.glsl │ ├── volumetric_clouds.glsl │ └── volumetric_clouds_post.glsl ├── ssao_ao.glsl ├── ssao_blur.glsl ├── ssao_downscale.glsl ├── ssr_composite.glsl ├── ssr_preconvolution.glsl ├── ssr_preintegration.glsl └── ssr_raytracing.glsl ├── thirdparty ├── CopyBinaries.bat ├── ThirdParty.vcxproj ├── ThirdParty.vcxproj.filters ├── assimp │ ├── binary │ │ ├── assimp-vc140-mt.dll │ │ └── assimp-vc140-mt.lib │ └── source │ │ └── assimp │ │ ├── .editorconfig │ │ ├── Compiler │ │ ├── poppack1.h │ │ ├── pstdint.h │ │ └── pushpack1.h │ │ ├── DefaultLogger.hpp │ │ ├── Exporter.hpp │ │ ├── IOStream.hpp │ │ ├── IOSystem.hpp │ │ ├── Importer.hpp │ │ ├── LogStream.hpp │ │ ├── Logger.hpp │ │ ├── NullLogger.hpp │ │ ├── ProgressHandler.hpp │ │ ├── ai_assert.h │ │ ├── anim.h │ │ ├── camera.h │ │ ├── cexport.h │ │ ├── cfileio.h │ │ ├── cimport.h │ │ ├── color4.h │ │ ├── color4.inl │ │ ├── config.h │ │ ├── defs.h │ │ ├── importerdesc.h │ │ ├── light.h │ │ ├── material.h │ │ ├── material.inl │ │ ├── matrix3x3.h │ │ ├── matrix3x3.inl │ │ ├── matrix4x4.h │ │ ├── matrix4x4.inl │ │ ├── mesh.h │ │ ├── metadata.h │ │ ├── port │ │ └── AndroidJNI │ │ │ └── AndroidJNIIOSystem.h │ │ ├── postprocess.h │ │ ├── quaternion.h │ │ ├── quaternion.inl │ │ ├── scene.h │ │ ├── texture.h │ │ ├── types.h │ │ ├── vector2.h │ │ ├── vector2.inl │ │ ├── vector3.h │ │ ├── vector3.inl │ │ └── version.h ├── bass │ └── bass24.zip ├── freeglut │ ├── binary │ │ ├── freeglut.dll │ │ ├── freeglut.lib │ │ ├── freeglutd.dll │ │ └── freeglutd.lib │ └── source │ │ └── GL │ │ ├── freeglut.h │ │ ├── freeglut_ext.h │ │ ├── freeglut_std.h │ │ └── glut.h ├── freeimage-3.18.0 │ ├── binary │ │ ├── FreeImage.dll │ │ └── FreeImage.lib │ └── source │ │ └── FreeImage.h ├── freetype-2.9.1 │ ├── binary │ │ └── freetype.lib │ └── source │ │ ├── freetype │ │ ├── config │ │ │ ├── ftconfig.h │ │ │ ├── ftheader.h │ │ │ ├── ftmodule.h │ │ │ ├── ftoption.h │ │ │ └── ftstdlib.h │ │ ├── freetype.h │ │ ├── ftadvanc.h │ │ ├── ftbbox.h │ │ ├── ftbdf.h │ │ ├── ftbitmap.h │ │ ├── ftbzip2.h │ │ ├── ftcache.h │ │ ├── ftchapters.h │ │ ├── ftcid.h │ │ ├── ftdriver.h │ │ ├── fterrdef.h │ │ ├── fterrors.h │ │ ├── ftfntfmt.h │ │ ├── ftgasp.h │ │ ├── ftglyph.h │ │ ├── ftgxval.h │ │ ├── ftgzip.h │ │ ├── ftimage.h │ │ ├── ftincrem.h │ │ ├── ftlcdfil.h │ │ ├── ftlist.h │ │ ├── ftlzw.h │ │ ├── ftmac.h │ │ ├── ftmm.h │ │ ├── ftmodapi.h │ │ ├── ftmoderr.h │ │ ├── ftotval.h │ │ ├── ftoutln.h │ │ ├── ftparams.h │ │ ├── ftpfr.h │ │ ├── ftrender.h │ │ ├── ftsizes.h │ │ ├── ftsnames.h │ │ ├── ftstroke.h │ │ ├── ftsynth.h │ │ ├── ftsystem.h │ │ ├── fttrigon.h │ │ ├── fttypes.h │ │ ├── ftwinfnt.h │ │ ├── internal │ │ │ ├── autohint.h │ │ │ ├── cffotypes.h │ │ │ ├── cfftypes.h │ │ │ ├── ftcalc.h │ │ │ ├── ftdebug.h │ │ │ ├── ftdrv.h │ │ │ ├── ftgloadr.h │ │ │ ├── fthash.h │ │ │ ├── ftmemory.h │ │ │ ├── ftobjs.h │ │ │ ├── ftpic.h │ │ │ ├── ftpsprop.h │ │ │ ├── ftrfork.h │ │ │ ├── ftserv.h │ │ │ ├── ftstream.h │ │ │ ├── fttrace.h │ │ │ ├── ftvalid.h │ │ │ ├── internal.h │ │ │ ├── psaux.h │ │ │ ├── pshints.h │ │ │ ├── services │ │ │ │ ├── svbdf.h │ │ │ │ ├── svcfftl.h │ │ │ │ ├── svcid.h │ │ │ │ ├── svfntfmt.h │ │ │ │ ├── svgldict.h │ │ │ │ ├── svgxval.h │ │ │ │ ├── svkern.h │ │ │ │ ├── svmetric.h │ │ │ │ ├── svmm.h │ │ │ │ ├── svotval.h │ │ │ │ ├── svpfr.h │ │ │ │ ├── svpostnm.h │ │ │ │ ├── svprop.h │ │ │ │ ├── svpscmap.h │ │ │ │ ├── svpsinfo.h │ │ │ │ ├── svsfnt.h │ │ │ │ ├── svttcmap.h │ │ │ │ ├── svtteng.h │ │ │ │ ├── svttglyf.h │ │ │ │ └── svwinfnt.h │ │ │ ├── sfnt.h │ │ │ ├── t1types.h │ │ │ └── tttypes.h │ │ ├── t1tables.h │ │ ├── ttnameid.h │ │ ├── tttables.h │ │ └── tttags.h │ │ └── ft2build.h ├── glm │ ├── glm.natvis │ └── source │ │ └── glm │ │ ├── CMakeLists.txt │ │ ├── common.hpp │ │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── compute_common.hpp │ │ ├── compute_vector_decl.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── func_common.inl │ │ ├── func_common_simd.inl │ │ ├── func_exponential.inl │ │ ├── func_exponential_simd.inl │ │ ├── func_geometric.inl │ │ ├── func_geometric_simd.inl │ │ ├── func_integer.inl │ │ ├── func_integer_simd.inl │ │ ├── func_matrix.inl │ │ ├── func_matrix_simd.inl │ │ ├── func_packing.inl │ │ ├── func_packing_simd.inl │ │ ├── func_trigonometric.inl │ │ ├── func_trigonometric_simd.inl │ │ ├── func_vector_relational.inl │ │ ├── func_vector_relational_simd.inl │ │ ├── glm.cpp │ │ ├── qualifier.hpp │ │ ├── setup.hpp │ │ ├── type_float.hpp │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_mat2x2.hpp │ │ ├── type_mat2x2.inl │ │ ├── type_mat2x3.hpp │ │ ├── type_mat2x3.inl │ │ ├── type_mat2x4.hpp │ │ ├── type_mat2x4.inl │ │ ├── type_mat3x2.hpp │ │ ├── type_mat3x2.inl │ │ ├── type_mat3x3.hpp │ │ ├── type_mat3x3.inl │ │ ├── type_mat3x4.hpp │ │ ├── type_mat3x4.inl │ │ ├── type_mat4x2.hpp │ │ ├── type_mat4x2.inl │ │ ├── type_mat4x3.hpp │ │ ├── type_mat4x3.inl │ │ ├── type_mat4x4.hpp │ │ ├── type_mat4x4.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── type_quat.hpp │ │ ├── type_quat.inl │ │ ├── type_quat_simd.inl │ │ ├── type_vec1.hpp │ │ ├── type_vec1.inl │ │ ├── type_vec2.hpp │ │ ├── type_vec2.inl │ │ ├── type_vec3.hpp │ │ ├── type_vec3.inl │ │ ├── type_vec4.hpp │ │ ├── type_vec4.inl │ │ └── type_vec4_simd.inl │ │ ├── exponential.hpp │ │ ├── ext.hpp │ │ ├── ext │ │ ├── _matrix_vectorize.hpp │ │ ├── matrix_clip_space.hpp │ │ ├── matrix_clip_space.inl │ │ ├── matrix_common.hpp │ │ ├── matrix_common.inl │ │ ├── matrix_double2x2.hpp │ │ ├── matrix_double2x2_precision.hpp │ │ ├── matrix_double2x3.hpp │ │ ├── matrix_double2x3_precision.hpp │ │ ├── matrix_double2x4.hpp │ │ ├── matrix_double2x4_precision.hpp │ │ ├── matrix_double3x2.hpp │ │ ├── matrix_double3x2_precision.hpp │ │ ├── matrix_double3x3.hpp │ │ ├── matrix_double3x3_precision.hpp │ │ ├── matrix_double3x4.hpp │ │ ├── matrix_double3x4_precision.hpp │ │ ├── matrix_double4x2.hpp │ │ ├── matrix_double4x2_precision.hpp │ │ ├── matrix_double4x3.hpp │ │ ├── matrix_double4x3_precision.hpp │ │ ├── matrix_double4x4.hpp │ │ ├── matrix_double4x4_precision.hpp │ │ ├── matrix_float2x2.hpp │ │ ├── matrix_float2x2_precision.hpp │ │ ├── matrix_float2x3.hpp │ │ ├── matrix_float2x3_precision.hpp │ │ ├── matrix_float2x4.hpp │ │ ├── matrix_float2x4_precision.hpp │ │ ├── matrix_float3x2.hpp │ │ ├── matrix_float3x2_precision.hpp │ │ ├── matrix_float3x3.hpp │ │ ├── matrix_float3x3_precision.hpp │ │ ├── matrix_float3x4.hpp │ │ ├── matrix_float3x4_precision.hpp │ │ ├── matrix_float4x2.hpp │ │ ├── matrix_float4x2_precision.hpp │ │ ├── matrix_float4x3.hpp │ │ ├── matrix_float4x3_precision.hpp │ │ ├── matrix_float4x4.hpp │ │ ├── matrix_float4x4_precision.hpp │ │ ├── matrix_int2x2.hpp │ │ ├── matrix_int2x2_sized.hpp │ │ ├── matrix_int2x3.hpp │ │ ├── matrix_int2x3_sized.hpp │ │ ├── matrix_int2x4.hpp │ │ ├── matrix_int2x4_sized.hpp │ │ ├── matrix_int3x2.hpp │ │ ├── matrix_int3x2_sized.hpp │ │ ├── matrix_int3x3.hpp │ │ ├── matrix_int3x3_sized.hpp │ │ ├── matrix_int3x4.hpp │ │ ├── matrix_int3x4_sized.hpp │ │ ├── matrix_int4x2.hpp │ │ ├── matrix_int4x2_sized.hpp │ │ ├── matrix_int4x3.hpp │ │ ├── matrix_int4x3_sized.hpp │ │ ├── matrix_int4x4.hpp │ │ ├── matrix_int4x4_sized.hpp │ │ ├── matrix_integer.hpp │ │ ├── matrix_integer.inl │ │ ├── matrix_projection.hpp │ │ ├── matrix_projection.inl │ │ ├── matrix_relational.hpp │ │ ├── matrix_relational.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── matrix_uint2x2.hpp │ │ ├── matrix_uint2x2_sized.hpp │ │ ├── matrix_uint2x3.hpp │ │ ├── matrix_uint2x3_sized.hpp │ │ ├── matrix_uint2x4.hpp │ │ ├── matrix_uint2x4_sized.hpp │ │ ├── matrix_uint3x2.hpp │ │ ├── matrix_uint3x2_sized.hpp │ │ ├── matrix_uint3x3.hpp │ │ ├── matrix_uint3x3_sized.hpp │ │ ├── matrix_uint3x4.hpp │ │ ├── matrix_uint3x4_sized.hpp │ │ ├── matrix_uint4x2.hpp │ │ ├── matrix_uint4x2_sized.hpp │ │ ├── matrix_uint4x3.hpp │ │ ├── matrix_uint4x3_sized.hpp │ │ ├── matrix_uint4x4.hpp │ │ ├── matrix_uint4x4_sized.hpp │ │ ├── quaternion_common.hpp │ │ ├── quaternion_common.inl │ │ ├── quaternion_common_simd.inl │ │ ├── quaternion_double.hpp │ │ ├── quaternion_double_precision.hpp │ │ ├── quaternion_exponential.hpp │ │ ├── quaternion_exponential.inl │ │ ├── quaternion_float.hpp │ │ ├── quaternion_float_precision.hpp │ │ ├── quaternion_geometric.hpp │ │ ├── quaternion_geometric.inl │ │ ├── quaternion_relational.hpp │ │ ├── quaternion_relational.inl │ │ ├── quaternion_transform.hpp │ │ ├── quaternion_transform.inl │ │ ├── quaternion_trigonometric.hpp │ │ ├── quaternion_trigonometric.inl │ │ ├── scalar_common.hpp │ │ ├── scalar_common.inl │ │ ├── scalar_constants.hpp │ │ ├── scalar_constants.inl │ │ ├── scalar_int_sized.hpp │ │ ├── scalar_integer.hpp │ │ ├── scalar_integer.inl │ │ ├── scalar_packing.hpp │ │ ├── scalar_packing.inl │ │ ├── scalar_reciprocal.hpp │ │ ├── scalar_reciprocal.inl │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── scalar_uint_sized.hpp │ │ ├── scalar_ulp.hpp │ │ ├── scalar_ulp.inl │ │ ├── vector_bool1.hpp │ │ ├── vector_bool1_precision.hpp │ │ ├── vector_bool2.hpp │ │ ├── vector_bool2_precision.hpp │ │ ├── vector_bool3.hpp │ │ ├── vector_bool3_precision.hpp │ │ ├── vector_bool4.hpp │ │ ├── vector_bool4_precision.hpp │ │ ├── vector_common.hpp │ │ ├── vector_common.inl │ │ ├── vector_double1.hpp │ │ ├── vector_double1_precision.hpp │ │ ├── vector_double2.hpp │ │ ├── vector_double2_precision.hpp │ │ ├── vector_double3.hpp │ │ ├── vector_double3_precision.hpp │ │ ├── vector_double4.hpp │ │ ├── vector_double4_precision.hpp │ │ ├── vector_float1.hpp │ │ ├── vector_float1_precision.hpp │ │ ├── vector_float2.hpp │ │ ├── vector_float2_precision.hpp │ │ ├── vector_float3.hpp │ │ ├── vector_float3_precision.hpp │ │ ├── vector_float4.hpp │ │ ├── vector_float4_precision.hpp │ │ ├── vector_int1.hpp │ │ ├── vector_int1_sized.hpp │ │ ├── vector_int2.hpp │ │ ├── vector_int2_sized.hpp │ │ ├── vector_int3.hpp │ │ ├── vector_int3_sized.hpp │ │ ├── vector_int4.hpp │ │ ├── vector_int4_sized.hpp │ │ ├── vector_integer.hpp │ │ ├── vector_integer.inl │ │ ├── vector_packing.hpp │ │ ├── vector_packing.inl │ │ ├── vector_reciprocal.hpp │ │ ├── vector_reciprocal.inl │ │ ├── vector_relational.hpp │ │ ├── vector_relational.inl │ │ ├── vector_uint1.hpp │ │ ├── vector_uint1_sized.hpp │ │ ├── vector_uint2.hpp │ │ ├── vector_uint2_sized.hpp │ │ ├── vector_uint3.hpp │ │ ├── vector_uint3_sized.hpp │ │ ├── vector_uint4.hpp │ │ ├── vector_uint4_sized.hpp │ │ ├── vector_ulp.hpp │ │ └── vector_ulp.inl │ │ ├── fwd.hpp │ │ ├── geometric.hpp │ │ ├── glm.cppm │ │ ├── glm.hpp │ │ ├── gtc │ │ ├── bitfield.hpp │ │ ├── bitfield.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── constants.hpp │ │ ├── constants.inl │ │ ├── epsilon.hpp │ │ ├── epsilon.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── matrix_access.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_integer.hpp │ │ ├── matrix_inverse.hpp │ │ ├── matrix_inverse.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── noise.hpp │ │ ├── noise.inl │ │ ├── packing.hpp │ │ ├── packing.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── quaternion_simd.inl │ │ ├── random.hpp │ │ ├── random.inl │ │ ├── reciprocal.hpp │ │ ├── reciprocal.inl │ │ ├── round.hpp │ │ ├── round.inl │ │ ├── type_aligned.hpp │ │ ├── type_precision.hpp │ │ ├── type_precision.inl │ │ ├── type_ptr.hpp │ │ ├── type_ptr.inl │ │ ├── ulp.hpp │ │ ├── ulp.inl │ │ └── vec1.hpp │ │ ├── gtx │ │ ├── associated_min_max.hpp │ │ ├── associated_min_max.inl │ │ ├── bit.hpp │ │ ├── bit.inl │ │ ├── closest_point.hpp │ │ ├── closest_point.inl │ │ ├── color_encoding.hpp │ │ ├── color_encoding.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── color_space_YCoCg.hpp │ │ ├── color_space_YCoCg.inl │ │ ├── common.hpp │ │ ├── common.inl │ │ ├── compatibility.hpp │ │ ├── compatibility.inl │ │ ├── component_wise.hpp │ │ ├── component_wise.inl │ │ ├── dual_quaternion.hpp │ │ ├── dual_quaternion.inl │ │ ├── easing.hpp │ │ ├── easing.inl │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── exterior_product.hpp │ │ ├── exterior_product.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_factorisation.hpp │ │ ├── matrix_factorisation.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── number_precision.inl │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── pca.hpp │ │ ├── pca.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── texture.hpp │ │ ├── texture.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ │ ├── integer.hpp │ │ ├── mat2x2.hpp │ │ ├── mat2x3.hpp │ │ ├── mat2x4.hpp │ │ ├── mat3x2.hpp │ │ ├── mat3x3.hpp │ │ ├── mat3x4.hpp │ │ ├── mat4x2.hpp │ │ ├── mat4x3.hpp │ │ ├── mat4x4.hpp │ │ ├── matrix.hpp │ │ ├── packing.hpp │ │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── neon.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ │ ├── trigonometric.hpp │ │ ├── vec2.hpp │ │ ├── vec3.hpp │ │ ├── vec4.hpp │ │ └── vector_relational.hpp ├── nlohmann-json-3.11.2 │ ├── CITATION.cff │ ├── LICENSE.MIT │ ├── LICENSES │ │ ├── Apache-2.0.txt │ │ ├── BSD-3-Clause.txt │ │ ├── GPL-3.0-only.txt │ │ └── MIT.txt │ ├── README.md │ ├── include │ │ └── nlohmann │ │ │ ├── adl_serializer.hpp │ │ │ ├── byte_container_with_subtype.hpp │ │ │ ├── detail │ │ │ ├── abi_macros.hpp │ │ │ ├── conversions │ │ │ │ ├── from_json.hpp │ │ │ │ ├── to_chars.hpp │ │ │ │ └── to_json.hpp │ │ │ ├── exceptions.hpp │ │ │ ├── hash.hpp │ │ │ ├── input │ │ │ │ ├── binary_reader.hpp │ │ │ │ ├── input_adapters.hpp │ │ │ │ ├── json_sax.hpp │ │ │ │ ├── lexer.hpp │ │ │ │ ├── parser.hpp │ │ │ │ └── position_t.hpp │ │ │ ├── iterators │ │ │ │ ├── internal_iterator.hpp │ │ │ │ ├── iter_impl.hpp │ │ │ │ ├── iteration_proxy.hpp │ │ │ │ ├── iterator_traits.hpp │ │ │ │ ├── json_reverse_iterator.hpp │ │ │ │ └── primitive_iterator.hpp │ │ │ ├── json_pointer.hpp │ │ │ ├── json_ref.hpp │ │ │ ├── macro_scope.hpp │ │ │ ├── macro_unscope.hpp │ │ │ ├── meta │ │ │ │ ├── call_std │ │ │ │ │ ├── begin.hpp │ │ │ │ │ └── end.hpp │ │ │ │ ├── cpp_future.hpp │ │ │ │ ├── detected.hpp │ │ │ │ ├── identity_tag.hpp │ │ │ │ ├── is_sax.hpp │ │ │ │ ├── std_fs.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ └── void_t.hpp │ │ │ ├── output │ │ │ │ ├── binary_writer.hpp │ │ │ │ ├── output_adapters.hpp │ │ │ │ └── serializer.hpp │ │ │ ├── string_concat.hpp │ │ │ ├── string_escape.hpp │ │ │ └── value_t.hpp │ │ │ ├── json.hpp │ │ │ ├── json_fwd.hpp │ │ │ ├── ordered_map.hpp │ │ │ └── thirdparty │ │ │ └── hedley │ │ │ ├── hedley.hpp │ │ │ └── hedley_undef.hpp │ ├── nlohmann_json.natvis │ └── single_include │ │ └── nlohmann │ │ ├── json.hpp │ │ └── json_fwd.hpp ├── opengl │ ├── GL │ │ ├── gl3w.h │ │ └── glcorearb.h │ └── KHR │ │ └── khrplatform.h ├── renderdoc │ └── renderdoc │ │ └── api │ │ ├── README.md │ │ └── app │ │ └── renderdoc_app.h ├── stbimage │ └── stb_image.h ├── tinygltf-2.6.3 │ ├── json.hpp │ ├── stb_image.h │ ├── stb_image_write.h │ └── tiny_gltf.h └── tinyobjloader │ └── tiny_obj_loader.h └── tools └── parse_glcorearb.rs /.gitattributes: -------------------------------------------------------------------------------- 1 | *.png filter=lfs diff=lfs merge=lfs -text 2 | *.jpg filter=lfs diff=lfs merge=lfs -text 3 | *.hdr filter=lfs diff=lfs merge=lfs -text 4 | *.ttf filter=lfs diff=lfs merge=lfs -text 5 | *.obj filter=lfs diff=lfs merge=lfs -text 6 | *.dae filter=lfs diff=lfs merge=lfs -text 7 | *.bmp filter=lfs diff=lfs merge=lfs -text 8 | *.max filter=lfs diff=lfs merge=lfs -text 9 | *.tga filter=lfs diff=lfs merge=lfs -text 10 | *.lib filter=lfs diff=lfs merge=lfs -text 11 | *.dll filter=lfs diff=lfs merge=lfs -text 12 | *.zip filter=lfs diff=lfs merge=lfs -text 13 | *.txt filter=lfs diff=lfs merge=lfs -text 14 | *.bin filter=lfs diff=lfs merge=lfs -text 15 | *.gltf filter=lfs diff=lfs merge=lfs -text -------------------------------------------------------------------------------- /EngineConfig.ini: -------------------------------------------------------------------------------- 1 | # ----------------------------------------------------- 2 | # Each line in this file is added to the debug console. 3 | # Lines that are empty or start with # are ignored. 4 | 5 | # ----------------------------------------------------- 6 | # Boot configs 7 | 8 | # Dump shader sources to log/shader_dump/ 9 | #r.dumpShaderSources 1 10 | 11 | # Dump device info to log/device_dump/ 12 | #r.dumpGLDevice 1 13 | 14 | # ----------------------------------------------------- 15 | # Post-processes 16 | 17 | # Screen space reflection (WIP) 18 | r.ssr.enable 0 19 | 20 | # Bloom 21 | #r.bloom 0 22 | 23 | # DoF (disabled as it makes the scene too blurry) 24 | r.dof.enable 0 25 | 26 | # Light probe based indirect lighting 27 | #r.probegi.enable 0 28 | 29 | # Anti-aliasing 30 | #r.antialiasing.method 0 31 | 32 | # FSR1 33 | #r.super_res.method 1 -------------------------------------------------------------------------------- /projects/App_RhythmGame/src/bass_wrapper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | #include 5 | 6 | class BassStream { 7 | 8 | public: 9 | BassStream(uint64 inHandle, const char* inSource) 10 | : handle(inHandle) 11 | , source(inSource) 12 | { 13 | } 14 | ~BassStream(); 15 | 16 | void startPlay(); 17 | 18 | void stop(); 19 | 20 | void setVolume(float vol); 21 | 22 | private: 23 | uint64 handle = 0; // HSTREAM 24 | std::string source; 25 | }; 26 | 27 | class BassWrapper { 28 | 29 | public: 30 | static bool initializeBASS(); 31 | static bool destroyBASS(); 32 | 33 | private: 34 | bool initialize(); 35 | bool destroy(); 36 | 37 | public: 38 | BassStream* createStreamFromFile(const char* filepath, float volume = 1.0f); 39 | BassStream* createStreamFromFile(const wchar_t* wFilepath, float volume = 1.0f); 40 | 41 | }; 42 | 43 | extern BassWrapper* gBass; 44 | -------------------------------------------------------------------------------- /projects/App_RhythmGame/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "world_rhythm_game.h" 2 | 3 | #include "pathos/core_minimal.h" 4 | using namespace pathos; 5 | 6 | const char* WINDOW_TITLE = "Rhythm Game"; 7 | const int32 WINDOW_WIDTH = 1920; 8 | const int32 WINDOW_HEIGHT = 1080; 9 | const bool WINDOW_FULLSCREEN = false; 10 | 11 | int main(int argc, char** argv) { 12 | EngineConfig engineConfig; 13 | engineConfig.windowWidth = WINDOW_WIDTH; 14 | engineConfig.windowHeight = WINDOW_HEIGHT; 15 | engineConfig.fullscreen = WINDOW_FULLSCREEN; 16 | engineConfig.title = WINDOW_TITLE; 17 | Engine::init(argc, argv, engineConfig); 18 | 19 | World* world = new World_RhythmGame; 20 | gEngine->setWorld(world); 21 | 22 | gEngine->start(); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /projects/App_RhythmGame/src/music_database.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | 5 | #include 6 | #include 7 | 8 | struct MusicDatabaseItem { 9 | std::string title; 10 | std::string musicFile; 11 | std::string recordFile; 12 | std::string backgroundFile; 13 | }; 14 | 15 | struct MusicDatabase { 16 | inline void addItem(const MusicDatabaseItem& item) { 17 | items.push_back(item); 18 | } 19 | 20 | inline uint32 numItems() const { return (uint32)items.size(); } 21 | 22 | std::vector items; 23 | }; 24 | 25 | // Returns false if failed to read the database. 26 | bool loadMusicDatabase(const char* filepath, const char* overridePath, MusicDatabase& outDB); 27 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/assertion/assertion.cpp: -------------------------------------------------------------------------------- 1 | #include "assertion.h" 2 | #include 3 | 4 | void CHECK_IMPL(int x, const char* file, int line) { 5 | static thread_local char buffer[2048]; 6 | if (!x) { 7 | sprintf_s(buffer, "Assertion failed !!! [FILE=%s] [LINE=%d]\n", file, line); 8 | puts(buffer); 9 | __debugbreak(); 10 | } 11 | } 12 | 13 | void CHECKF_IMPL(int x, const char* msg, const char* file, int line) { 14 | static thread_local char buffer[2048]; 15 | if (!x) { 16 | sprintf_s(buffer, "Assertion failed !!! [MSG=%s] [FILE=%s] [LINE=%d]\n", msg, file, line); 17 | puts(buffer); 18 | __debugbreak(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/assertion/assertion.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | void CHECK_IMPL(int x, const char* file, int line); 6 | void CHECKF_IMPL(int x, const char* msg, const char* file, int line); 7 | 8 | #ifndef ASSERT 9 | #define ASSERT(x) assert(x) 10 | #endif 11 | 12 | #ifndef CHECK 13 | #define CHECK(x) CHECK_IMPL(!!(x), __FILE__, __LINE__) 14 | #endif 15 | 16 | #ifndef CHECKF 17 | #define CHECKF(x, msg) CHECKF_IMPL(!!(x), msg, __FILE__, __LINE__) 18 | #endif 19 | 20 | #define CHECK_NO_ENTRY() CHECK(false) 21 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/math/convex_hull.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace badger { 6 | 7 | struct ConvexHullTriangle { size_t a, b, c; }; 8 | 9 | struct Edge { 10 | size_t a, b; 11 | bool operator==(const Edge& rhs) const { 12 | return (a == rhs.a && b == rhs.b) || (a == rhs.b && b == rhs.a); 13 | } 14 | }; 15 | 16 | void buildConvexHull( 17 | const std::vector& vertices, 18 | std::vector& outHullPoints, 19 | std::vector& outHullTriangles); 20 | 21 | vector3 calculateCenterOfMass( 22 | const std::vector& points, 23 | const std::vector& triangles); 24 | 25 | matrix3 calculateInertiaTensor( 26 | const std::vector& points, 27 | const std::vector& triangles, 28 | const vector3& centerOfMass); 29 | 30 | } 31 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/math/minmax.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #undef min 4 | #undef max 5 | 6 | namespace badger { 7 | 8 | template 9 | T min(T x, T y) { 10 | return (x < y) ? x : y; 11 | } 12 | 13 | template 14 | T max(T x, T y) { 15 | return (x < y) ? y : x; 16 | } 17 | 18 | // #todo-math: Exotic order? Is (value, minValue, maxValue) more common? 19 | template 20 | T clamp(T minValue, T value, T maxValue) { 21 | return (value < minValue) ? minValue : value > maxValue ? maxValue : value; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/math/vector_math.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/vector_types.h" 4 | 5 | namespace badger { 6 | 7 | // Given N (assuming normalized), returns two arbitrary vectors T and B to form an orthonormal basis. 8 | inline void calculateOrthonormalBasis(const vector3& N, vector3& outT, vector3& outB) { 9 | vector3 T(0.0f, 1.0f, 0.0f); 10 | 11 | // if almost parallel, choose another random direction 12 | float angle = glm::dot(N, T); 13 | if (fabs(angle) >= 0.999f) { 14 | T = vector3(1.0f, 0.0f, 0.0f); 15 | } 16 | 17 | outB = glm::normalize(glm::cross(N, T)); 18 | outT = glm::cross(outB, N); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/physics/physics_scene.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "shape.h" 4 | #include 5 | 6 | namespace badger { 7 | namespace physics { 8 | 9 | class PhysicsScene { 10 | 11 | public: 12 | void initialize(); 13 | void update(float deltaSeconds); 14 | 15 | Body* allocateBody(); 16 | void releaseBody(Body* body); 17 | 18 | private: 19 | // #todo-physics: Memory access is not cache friendly :( 20 | // Maybe import FreeNumberList from Cyseal and expose int32 handles rather than pointers? 21 | std::vector bodies; 22 | 23 | }; 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/system/cpu.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | #include "badger/system/platform.h" 5 | 6 | #if PLATFORM_WINDOWS 7 | using PlatformThreadId = uint32; 8 | #else 9 | #error "PlatformThreadId is undefined for the target platform." 10 | #endif 11 | 12 | class CPU final { 13 | 14 | public: 15 | static uint32 getTotalLogicalCoreCount(); 16 | 17 | // #note-cpu: It can change within a single function. Usually it's good to use thread id instead. 18 | static uint32 getCurrentLogicalCoreIndex(); 19 | 20 | static PlatformThreadId getCurrentThreadId(); 21 | 22 | static void setCurrentThreadName(const wchar_t* name); 23 | 24 | }; 25 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/system/mem_alloc.cpp: -------------------------------------------------------------------------------- 1 | #include "mem_alloc.h" 2 | 3 | StackAllocator::StackAllocator(uint32 bytes) 4 | { 5 | memblock = ::malloc(bytes); 6 | current = memblock; 7 | totalBytes = bytes; 8 | usedBytes = 0; 9 | } 10 | 11 | StackAllocator::~StackAllocator() 12 | { 13 | ::free(memblock); 14 | } 15 | 16 | void* StackAllocator::alloc(uint32 bytes) 17 | { 18 | CHECK(bytes > 0); 19 | 20 | if (usedBytes + bytes > totalBytes) 21 | { 22 | return nullptr; 23 | } 24 | 25 | void* block = (void*)(reinterpret_cast(memblock) + usedBytes); 26 | usedBytes += bytes; 27 | 28 | return block; 29 | } 30 | 31 | void StackAllocator::clear() 32 | { 33 | usedBytes = 0; 34 | } 35 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/system/platform.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // === Platform checklist === 4 | // [v] Windows : Supported 5 | // [ ] Linux : No plan 6 | // [ ] Android : No plan 7 | // [ ] Mac : No plan 8 | // [ ] iOS : No plan 9 | 10 | // ---------------------------------------------------------------------------- 11 | // Windows 12 | 13 | #if (defined(_WIN32) && _WIN32) || (defined(_WIN64) && _WIN64) 14 | #define PLATFORM_WINDOWS 1 15 | #endif 16 | 17 | #ifndef PLATFORM_WINDOWS 18 | #define PLATFORM_WINDOWS 0 19 | #endif 20 | 21 | // ---------------------------------------------------------------------------- 22 | // 23 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/system/stopwatch.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | struct Stopwatch { 6 | 7 | public: 8 | Stopwatch() { 9 | startTime = std::chrono::system_clock::now(); 10 | } 11 | 12 | inline void start() { 13 | startTime = std::chrono::system_clock::now(); 14 | } 15 | 16 | // Elapsed milliseconds since start() 17 | inline float stop() const { 18 | auto diff = std::chrono::system_clock::now() - startTime; 19 | std::chrono::microseconds elapsedMicro 20 | = std::chrono::duration_cast(diff); 21 | 22 | return 0.001f * (float)elapsedMicro.count(); 23 | } 24 | 25 | private: 26 | std::chrono::system_clock::time_point startTime; 27 | 28 | }; 29 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/types/int_types.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | using int8 = int8_t; 6 | using int16 = int16_t; 7 | using int32 = int32_t; 8 | using int64 = int64_t; 9 | 10 | using uint8 = uint8_t; 11 | using uint16 = uint16_t; 12 | using uint32 = uint32_t; 13 | using uint64 = uint64_t; 14 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/types/matrix_types.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | using matrix2 = glm::mat2x2; 7 | using matrix3 = glm::mat3x3; 8 | using matrix4 = glm::mat4x4; 9 | using matrix3x4 = glm::mat3x4; 10 | using matrix4x3 = glm::mat4x3; 11 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/types/noncopyable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Noncopyable { 4 | 5 | public: 6 | Noncopyable() = default; 7 | ~Noncopyable() = default; 8 | 9 | Noncopyable(const Noncopyable&) = delete; 10 | Noncopyable& operator=(const Noncopyable&) = delete; 11 | 12 | }; 13 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/badger/types/vector_types.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "glm/glm.hpp" 4 | 5 | // #todo-math: double type (open world scale) 6 | using vector2 = glm::vec2; 7 | using vector3 = glm::vec3; 8 | using vector4 = glm::vec4; 9 | 10 | using vector2i = glm::ivec2; 11 | using vector3i = glm::ivec3; 12 | using vector4i = glm::ivec4; 13 | 14 | using vector2ui = glm::uvec2; 15 | using vector3ui = glm::uvec3; 16 | using vector4ui = glm::uvec4; 17 | 18 | using vector2b = glm::bvec2; 19 | using vector3b = glm::bvec3; 20 | using vector4b = glm::bvec4; 21 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/core_minimal.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "engine.h" 4 | #include "console.h" 5 | #include "util/log.h" 6 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/engine_policy.cpp: -------------------------------------------------------------------------------- 1 | #include "engine_policy.h" 2 | 3 | namespace pathos { 4 | 5 | // 6 | 7 | } 8 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/engine_version.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /** 4 | * Criteria 5 | * - Tag a milestone for each work in my kanban board. (https://github.com/users/codeonwort/projects/8) 6 | * - Increase engine version when a work is finished and merged to master branch. 7 | */ 8 | #define PATHOS_MAJOR_VERSION 0 9 | #define PATHOS_MINOR_VERSION 6 10 | #define PATHOS_PATCH_VERSION 11 11 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/loader/spline_loader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/noncopyable.h" 4 | #include "badger/math/spline.h" 5 | #include 6 | 7 | namespace pathos { 8 | 9 | class SplineLoader : public Noncopyable { 10 | 11 | public: 12 | SplineLoader() = default; 13 | ~SplineLoader() = default; 14 | 15 | bool load(const char* inFilename, bool bMakeLoop, std::string& outName, HermiteSpline& outSpline); 16 | 17 | }; 18 | 19 | } 20 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/material/material_id.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | 5 | namespace pathos { 6 | 7 | enum class EMaterialShadingModel : uint8 { 8 | INVALID = 0, 9 | UNLIT = 1, 10 | DEFAULTLIT = 2, 11 | TRANSLUCENT = 3, 12 | //SKIN = 3, 13 | //HAIR = 4, 14 | 15 | NUM_MODELS = 3, 16 | }; 17 | static_assert((uint32)EMaterialShadingModel::NUM_MODELS <= 0xff, "Too many shading models"); 18 | 19 | } 20 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/material/material_parameter.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | #include 5 | 6 | namespace pathos { 7 | 8 | class Texture; 9 | 10 | enum class EMaterialParameterDataType : uint32 { 11 | Float, 12 | Int, 13 | Uint, 14 | Bool 15 | }; 16 | 17 | struct MaterialConstantParameter { 18 | std::string name; 19 | EMaterialParameterDataType datatype; 20 | uint32 numElements; 21 | union { 22 | float fvalue[4]; 23 | int32 ivalue[4]; 24 | uint32 uvalue[4]; 25 | bool bvalue[4]; 26 | }; 27 | uint32 offset; // in UBO 28 | }; 29 | 30 | struct MaterialTextureParameter { 31 | std::string name; 32 | uint32 binding; 33 | Texture* texture = nullptr; 34 | }; 35 | 36 | } 37 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/material/material_proxy.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "material_id.h" 4 | #include "material_parameter.h" 5 | 6 | #include 7 | 8 | namespace pathos { 9 | 10 | class MaterialShader; 11 | 12 | class MaterialProxy { 13 | 14 | public: 15 | struct UBO_PerObject { 16 | static constexpr uint32 BINDING_POINT = 1; 17 | 18 | // #todo-material: Upload only object ID. Read model transform from some buffer. 19 | matrix4 modelTransform; 20 | matrix4 prevModelTransform; 21 | }; 22 | 23 | void fillUniformBuffer(uint8* uboMemory); 24 | 25 | EMaterialShadingModel getShadingModel() const; 26 | 27 | public: 28 | MaterialShader* materialShader; 29 | uint32 materialInstanceID; 30 | bool bWireframe; 31 | 32 | public: 33 | std::vector constantParameters; 34 | std::vector textureParameters; 35 | }; 36 | 37 | } 38 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/mesh/static_mesh.cpp: -------------------------------------------------------------------------------- 1 | #include "static_mesh.h" 2 | 3 | namespace pathos { 4 | 5 | StaticMesh::StaticMesh() { 6 | } 7 | 8 | StaticMesh::StaticMesh(assetPtr geom, assetPtr mat) { 9 | bool bothNull = geom == nullptr && mat == nullptr; 10 | bool bothValid = geom != nullptr && mat != nullptr; 11 | 12 | // Only 'both null' or 'both not null' are allowed 13 | CHECK(bothNull || bothValid); 14 | 15 | if (bothValid) { 16 | addSection(0, geom, mat); 17 | } 18 | } 19 | 20 | StaticMesh::~StaticMesh() { 21 | lodArray.clear(); 22 | } 23 | 24 | void pathos::StaticMesh::addSection(uint32 lod, assetPtr G, assetPtr M) { 25 | CHECK(lod >= 0 && G != nullptr && M != nullptr); 26 | if ((uint32)lodArray.size() <= lod) { 27 | lodArray.resize(lod + 1); 28 | } 29 | 30 | lodArray[lod].geometries.push_back(G); 31 | lodArray[lod].materials.push_back(M); 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/overlay/button.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "display_object.h" 4 | 5 | namespace pathos { 6 | 7 | class Rectangle; 8 | class Label; 9 | class SolidColorBrush; 10 | 11 | class Button : public DisplayObject2D { 12 | 13 | public: 14 | Button(float width, float height, float paddingX, float paddingY); 15 | virtual ~Button(); 16 | 17 | // User input 18 | virtual bool onMouseHitTest(int32 mouseX, int32 mouseY) const override; 19 | 20 | void setBackgroundColor(float r, float g, float b); 21 | 22 | void setText(const wchar_t* txt); 23 | void setTextColor(float r, float g, float b); 24 | 25 | private: 26 | Rectangle* background = nullptr; 27 | SolidColorBrush* backgroundBrush = nullptr; 28 | Label* label = nullptr; 29 | 30 | }; 31 | 32 | } 33 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/overlay/label.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "display_object.h" 4 | #include "pathos/text/text_geometry.h" 5 | #include "pathos/text/font_mgr.h" 6 | #include "pathos/smart_pointer.h" 7 | 8 | #include 9 | 10 | namespace pathos { 11 | 12 | class Label : public DisplayObject2D { 13 | 14 | public: 15 | Label(); 16 | Label(const wchar_t* text); 17 | ~Label(); 18 | 19 | DisplayObject2DProxy* createRenderProxy(OverlaySceneProxy* sceneProxy) override; 20 | 21 | void setText(const wchar_t* newText); 22 | void setColor(const vector3& newColor); 23 | void setFont(const std::string& tag); 24 | 25 | uint32 getTextWidth() const; 26 | 27 | const std::wstring& getText() const { return text; } 28 | std::wstring getText() { return text; } 29 | 30 | protected: 31 | virtual void updateTransform(uint32 viewportWidth, uint32 viewportHeight) override; 32 | 33 | private: 34 | std::wstring text; 35 | assetPtr geometry; 36 | FontDesc fontDesc; 37 | 38 | }; 39 | 40 | } 41 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/overlay/rectangle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "display_object.h" 4 | #include "pathos/mesh/geometry_primitive.h" 5 | 6 | namespace pathos { 7 | 8 | class Rectangle : public DisplayObject2D { 9 | 10 | public: 11 | Rectangle(float inWidth, float inHeight); 12 | 13 | DisplayObject2DProxy* createRenderProxy(OverlaySceneProxy* sceneProxy) override; 14 | 15 | // User input 16 | virtual bool onMouseHitTest(int32 mouseX, int32 mouseY) const override; 17 | 18 | void setSize(float inWidth, float inHeight); 19 | 20 | inline float getWidth() const { return width * scaleX; } 21 | inline float getHeight() const { return height * scaleY; } 22 | inline float getUnscaledWidth() const { return width; } 23 | inline float getUnscaledHeight() const { return height; } 24 | 25 | protected: 26 | float width; 27 | float height; 28 | assetPtr geom; 29 | 30 | virtual void updateTransform(uint32 viewportWidth, uint32 viewportHeight) override; 31 | 32 | }; 33 | 34 | } 35 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/forward/translucency_rendering.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/uniform_buffer.h" 4 | #include "pathos/rhi/render_command_list.h" 5 | #include "pathos/scene/camera.h" 6 | 7 | namespace pathos { 8 | 9 | class SceneProxy; 10 | struct StaticMeshProxy; 11 | 12 | class TranslucencyRendering final { 13 | 14 | public: 15 | TranslucencyRendering(); 16 | 17 | void initializeResources(RenderCommandList& cmdList); 18 | void releaseResources(RenderCommandList& cmdList); 19 | 20 | void renderTranslucency( 21 | RenderCommandList& cmdList, 22 | const SceneProxy* scene, 23 | const Camera* camera); 24 | 25 | private: 26 | GLuint fbo = 0xffffffff; 27 | UniformBuffer uboPerObject; 28 | UniformBuffer uboLightInfo; 29 | 30 | }; 31 | 32 | } 33 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/gbuffer_pass.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/uniform_buffer.h" 4 | #include "pathos/rhi/gl_handles.h" 5 | 6 | namespace pathos { 7 | 8 | class SceneProxy; 9 | class LandscapeRendering; 10 | struct SceneRenderTargets; 11 | 12 | class GBufferPass final { 13 | 14 | public: 15 | GBufferPass(); 16 | ~GBufferPass(); 17 | 18 | void initializeResources(RenderCommandList& cmdList); 19 | 20 | void releaseResources(RenderCommandList& cmdList); 21 | 22 | void renderGBuffers(RenderCommandList& cmdList, SceneProxy* scene, bool hasDepthPrepass, LandscapeRendering* landscapeRendering); 23 | 24 | private: 25 | void updateFramebufferAttachments(RenderCommandList& cmdList, SceneRenderTargets* sceneRenderTargets); 26 | 27 | private: 28 | GLuint fbo = 0; 29 | UniformBuffer uboPerObject; 30 | 31 | }; 32 | 33 | } 34 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/overlay/overlaypass.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "overlaypass_base.h" 4 | #include "overlaypass_standard.h" 5 | #include "overlaypass_text.h" 6 | #include "overlaypass_image.h" 7 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/overlay/overlaypass_base.cpp: -------------------------------------------------------------------------------- 1 | #include "overlaypass_base.h" 2 | #include "pathos/rhi/render_device.h" 3 | 4 | namespace pathos { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/overlay/overlaypass_base.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/gl_handles.h" 4 | #include "pathos/rhi/render_command_list.h" 5 | #include "pathos/overlay/display_object.h" 6 | #include "pathos/util/transform_helper.h" 7 | 8 | #include "badger/types/noncopyable.h" 9 | 10 | namespace pathos { 11 | 12 | class DisplayObject2DProxy; 13 | 14 | class OverlayPass : public Noncopyable { 15 | 16 | public: 17 | virtual ~OverlayPass() = default; 18 | 19 | virtual void renderOverlay( 20 | RenderCommandList& cmdList, 21 | DisplayObject2DProxy* object, 22 | const Transform& transformAccum) = 0; 23 | 24 | }; 25 | 26 | } 27 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/overlay/overlaypass_image.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "overlaypass_base.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | namespace pathos { 7 | 8 | class DisplayObject2DProxy; 9 | 10 | // standard render pass that uses color and texture 11 | class OverlayPass_Image : public OverlayPass { 12 | 13 | public: 14 | OverlayPass_Image(); 15 | 16 | virtual void renderOverlay( 17 | RenderCommandList& cmdList, 18 | DisplayObject2DProxy* object, 19 | const Transform& transformAccum) override; 20 | 21 | inline void setImageTexture(GLuint texture) { textureName = texture; } 22 | 23 | private: 24 | UniformBuffer ubo; 25 | GLuint textureName = 0; 26 | 27 | }; 28 | 29 | } 30 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/overlay/overlaypass_standard.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "overlaypass_base.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | namespace pathos { 7 | 8 | class DisplayObject2DProxy; 9 | 10 | // standard render pass that uses color and texture 11 | class OverlayPass_Standard : public OverlayPass { 12 | 13 | public: 14 | OverlayPass_Standard(); 15 | ~OverlayPass_Standard() = default; 16 | 17 | virtual void renderOverlay( 18 | RenderCommandList& cmdList, 19 | DisplayObject2DProxy* object, 20 | const Transform& transformAccum) override; 21 | 22 | inline void setColor(const vector4& inColor) { rgba = inColor; } 23 | 24 | private: 25 | UniformBuffer ubo; 26 | vector4 rgba; 27 | 28 | }; 29 | 30 | } 31 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/overlay/overlaypass_text.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "overlaypass_base.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | #include "badger/types/vector_types.h" 7 | 8 | namespace pathos { 9 | 10 | class DisplayObject2DProxy; 11 | 12 | class OverlayPass_Text : public OverlayPass { 13 | 14 | public: 15 | OverlayPass_Text(); 16 | ~OverlayPass_Text() = default; 17 | 18 | virtual void renderOverlay( 19 | RenderCommandList& cmdList, 20 | DisplayObject2DProxy* object, 21 | const Transform& transformAccum) override; 22 | 23 | inline void setColor(const vector4& inColor) { color = inColor; } 24 | 25 | private: 26 | UniformBuffer ubo; 27 | vector4 color; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/anti_aliasing.cpp: -------------------------------------------------------------------------------- 1 | #include "anti_aliasing.h" 2 | #include "pathos/console.h" 3 | #include "badger/math/minmax.h" 4 | 5 | namespace pathos { 6 | 7 | static ConsoleVariable cvar_anti_aliasing( 8 | "r.antialiasing.method", 9 | 2, 10 | "0 = None, 1 = FXAA, 2 = TAA"); 11 | 12 | static ConsoleVariable cvar_temporalJitterMultiplier( 13 | "r.taa.jitterMultiplier", 14 | 1.0f, 15 | "Temporal jitter multiplier"); 16 | 17 | EAntiAliasingMethod getAntiAliasingMethod() { 18 | int32 total = (int32)EAntiAliasingMethod::NumMethods; 19 | return (EAntiAliasingMethod)badger::clamp(0, cvar_anti_aliasing.getInt(), total); 20 | } 21 | 22 | float getTemporalJitterMultiplier() { 23 | return badger::clamp(0.0f, cvar_temporalJitterMultiplier.getFloat(), 10.0f); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/anti_aliasing.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | 5 | namespace pathos { 6 | 7 | enum class EAntiAliasingMethod : uint8 { 8 | NoAA = 0, // Skip anti-aliasing pass 9 | FXAA = 1, // NVidia FXAA 10 | TAA = 2, 11 | NumMethods = 3 12 | }; 13 | 14 | EAntiAliasingMethod getAntiAliasingMethod(); 15 | 16 | float getTemporalJitterMultiplier(); 17 | 18 | } 19 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/anti_aliasing_fxaa.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "post_process.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | // NVidia FXAA wrapper 7 | 8 | namespace pathos { 9 | 10 | class FXAA final : public PostProcess { 11 | 12 | public: 13 | virtual void initializeResources(RenderCommandList& cmdList) override; 14 | virtual void releaseResources(RenderCommandList& cmdList) override; 15 | virtual void renderPostProcess(RenderCommandList& cmdList, MeshGeometry* fullscreenQuad) override; 16 | 17 | private: 18 | GLuint fbo = 0; 19 | UniformBuffer ubo; 20 | 21 | }; 22 | 23 | } 24 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/anti_aliasing_taa.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "post_process.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | // Temporal anti-aliasing 7 | 8 | namespace pathos { 9 | 10 | class TAA final : public PostProcess { 11 | 12 | public: 13 | virtual void initializeResources(RenderCommandList& cmdList) override; 14 | virtual void releaseResources(RenderCommandList& cmdList) override; 15 | virtual void renderPostProcess(RenderCommandList& cmdList, MeshGeometry* fullscreenQuad) override; 16 | 17 | private: 18 | GLuint fbo = 0; 19 | UniformBuffer ubo; 20 | 21 | }; 22 | 23 | } 24 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/bloom.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "post_process.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | namespace pathos { 7 | 8 | class BloomPass : public PostProcess { 9 | 10 | public: 11 | virtual void initializeResources(RenderCommandList& cmdList) override; 12 | virtual void releaseResources(RenderCommandList& cmdList) override; 13 | virtual void renderPostProcess(RenderCommandList& cmdList, MeshGeometry* fullscreenQuad) override; 14 | 15 | private: 16 | GLuint fbo; 17 | UniformBuffer uboUpsample; 18 | 19 | }; 20 | 21 | } 22 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/bloom_setup.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "post_process.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | namespace pathos { 7 | 8 | class BloomSetup : public PostProcess { 9 | 10 | public: 11 | virtual void initializeResources(RenderCommandList& cmdList) override; 12 | virtual void releaseResources(RenderCommandList& cmdList) override; 13 | virtual void renderPostProcess(RenderCommandList& cmdList, MeshGeometry* fullscreenQuad) override; 14 | 15 | private: 16 | GLuint fbo = 0; 17 | UniformBuffer ubo; 18 | 19 | }; 20 | 21 | } 22 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/depth_of_field.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "post_process.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | 7 | namespace pathos { 8 | 9 | class DepthOfField : public PostProcess { 10 | 11 | public: 12 | ~DepthOfField(); 13 | 14 | virtual void initializeResources(RenderCommandList& cmdList) override; 15 | virtual void releaseResources(RenderCommandList& cmdList) override; 16 | virtual void renderPostProcess(RenderCommandList& cmdList, MeshGeometry* fullscreenQuad) override; 17 | 18 | bool isAvailable() const; 19 | 20 | private: 21 | GLuint createBlurShader(); 22 | 23 | GLuint vao = 0; 24 | GLuint fbo = 0; 25 | UniformBuffer uboPrefixSum; 26 | UniformBuffer uboBlur; 27 | 28 | }; 29 | 30 | } 31 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/post_process.cpp: -------------------------------------------------------------------------------- 1 | #include "post_process.h" 2 | #include "pathos/util/log.h" 3 | 4 | #include "badger/assertion/assertion.h" 5 | 6 | namespace pathos { 7 | 8 | PostProcess::~PostProcess() { 9 | CHECKF(resourcesDestroyed, "Child classes should override releaseResources() and set this true at the end."); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/super_res.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/console.h" 4 | 5 | #include "badger/types/int_types.h" 6 | 7 | namespace pathos { 8 | 9 | enum class ESuperResolutionMethod : uint8 { 10 | Disabled = 0, 11 | FSR1 = 1, 12 | }; 13 | 14 | enum class EFSR1QualityMode : uint8 { 15 | UltraQuality, 16 | Quality, 17 | Balanced, 18 | Performance 19 | }; 20 | 21 | ESuperResolutionMethod getSuperResolutionMethod(); 22 | float getSuperResolutionScaleFactor(); 23 | 24 | } 25 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/postprocessing/super_res_fsr1.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "post_process.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | // AMD FSR1 (https://gpuopen.com/fidelityfx-superresolution/) 7 | 8 | namespace pathos { 9 | 10 | class FSR1 final : public PostProcess { 11 | 12 | public: 13 | virtual void initializeResources(RenderCommandList& cmdList) override; 14 | virtual void releaseResources(RenderCommandList& cmdList) override; 15 | virtual void renderPostProcess(RenderCommandList& cmdList, MeshGeometry* fullscreenQuad) override; 16 | 17 | private: 18 | UniformBuffer ubo; 19 | 20 | }; 21 | 22 | } 23 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/resolve_unlit.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/render_command_list.h" 4 | 5 | // Resolve unlit color into sceneColor. 6 | 7 | namespace pathos { 8 | 9 | class MeshGeometry; 10 | 11 | class ResolveUnlitPass { 12 | 13 | public: 14 | ResolveUnlitPass(); 15 | ~ResolveUnlitPass(); 16 | 17 | void initializeResources(RenderCommandList& cmdList); 18 | void releaseResources(RenderCommandList& cmdList); 19 | 20 | void renderUnlit( 21 | RenderCommandList& cmdList, 22 | MeshGeometry* fullscreenQuad); 23 | 24 | private: 25 | GLuint fbo = 0xffffffff; 26 | 27 | bool destroyed = false; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/shadow_omni.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/gl_handles.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | #include "pathos/scene/camera.h" 6 | 7 | #include "badger/types/noncopyable.h" 8 | #include 9 | 10 | namespace pathos { 11 | 12 | // Shadow pass for point lights. 13 | class OmniShadowPass : public Noncopyable { 14 | static const uint32 SHADOW_MAP_SIZE; 15 | 16 | public: 17 | OmniShadowPass() = default; 18 | virtual ~OmniShadowPass() = default; 19 | 20 | void initializeResources(RenderCommandList& cmdList); 21 | void releaseResources(RenderCommandList& cmdList); 22 | void renderShadowMaps(RenderCommandList& cmdList, const SceneProxy* scene, const Camera* camera); 23 | 24 | private: 25 | GLuint fbo = 0; 26 | UniformBuffer ubo; 27 | }; 28 | 29 | } 30 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/visualize_buffer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/core_minimal.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | namespace pathos { 7 | 8 | class SceneProxy; 9 | class Camera; 10 | 11 | class VisualizeBufferPass { 12 | 13 | public: 14 | VisualizeBufferPass(); 15 | ~VisualizeBufferPass(); 16 | 17 | void initializeResources(RenderCommandList& cmdList); 18 | void releaseResources(RenderCommandList& cmdList); 19 | void render(RenderCommandList& cmdList, SceneProxy* scene, Camera* camera); 20 | 21 | private: 22 | GLuint dummyVAO; 23 | UniformBuffer ubo; 24 | 25 | }; 26 | 27 | } 28 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/visualize_indirect_diffuse.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/uniform_buffer.h" 4 | 5 | // NOTE: Which term to use between Sky Visibility and Sky Occlusion? 6 | // I chose 'occlusion' because it aligns with other terms such as Ambient Occlusion and Specular Occlusion, 7 | // though in formula 'visibility' is more intuitive (0 = fully occluded, 1 = fully visible). 8 | 9 | namespace pathos { 10 | 11 | class SceneProxy; 12 | class Camera; 13 | 14 | class VisualizeIndirectDiffuse { 15 | 16 | public: 17 | VisualizeIndirectDiffuse(); 18 | ~VisualizeIndirectDiffuse(); 19 | 20 | void initializeResources(RenderCommandList& cmdList); 21 | void releaseResources(RenderCommandList& cmdList); 22 | 23 | void renderVisualization(RenderCommandList& cmdList, SceneProxy* scene); 24 | 25 | private: 26 | GLuint fbo = 0; 27 | UniformBuffer ubo; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render/visualize_light_probe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/core_minimal.h" 4 | #include "pathos/rhi/uniform_buffer.h" 5 | 6 | namespace pathos { 7 | 8 | class SceneProxy; 9 | class Camera; 10 | class SphereGeometry; 11 | class Buffer; 12 | 13 | class VisualizeLightProbePass { 14 | 15 | public: 16 | VisualizeLightProbePass(); 17 | ~VisualizeLightProbePass(); 18 | 19 | void initializeResources(RenderCommandList& cmdList); 20 | void releaseResources(RenderCommandList& cmdList); 21 | 22 | void render(RenderCommandList& cmdList, SceneProxy* scene); 23 | 24 | private: 25 | SphereGeometry* sphereGeom = nullptr; 26 | GLuint fbo = 0; 27 | UniformBuffer ubo; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/render_minimal.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/util/resource_finder.h" 4 | 5 | #include "pathos/scene/scene.h" 6 | #include "pathos/scene/camera.h" 7 | 8 | #include "pathos/scene/sky_atmosphere_actor.h" 9 | #include "pathos/scene/skybox_actor.h" 10 | #include "pathos/scene/sky_panorama_actor.h" 11 | 12 | #include "pathos/scene/directional_light_actor.h" 13 | #include "pathos/scene/directional_light_component.h" 14 | #include "pathos/scene/point_light_actor.h" 15 | #include "pathos/scene/point_light_component.h" 16 | 17 | #include "pathos/mesh/static_mesh.h" 18 | #include "pathos/mesh/geometry_primitive.h" 19 | 20 | #include "pathos/material/material.h" 21 | #include "pathos/material/material_shader.h" 22 | 23 | #include "pathos/loader/image_loader.h" 24 | #include "pathos/loader/objloader.h" 25 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/rhi/gl_handles.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Forward decl. of just GL datatypes to avoid including full GL headers. 4 | 5 | typedef void GLvoid; 6 | typedef unsigned int GLenum; 7 | #include 8 | typedef khronos_float_t GLfloat; 9 | typedef int GLint; 10 | typedef int GLsizei; 11 | typedef unsigned int GLbitfield; 12 | typedef double GLdouble; 13 | typedef unsigned int GLuint; 14 | typedef unsigned char GLboolean; 15 | typedef khronos_uint8_t GLubyte; 16 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/rhi/indirect_draw.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // https://registry.khronos.org/OpenGL-Refpages/gl4/html/glMultiDrawElementsIndirect.xhtml 4 | // MDI parameters to fill in an indirect draw buffer. 5 | // 6 | // Example usage: 7 | // 8 | // std::vector commands(drawCount); 9 | // for (size_t i = 0; i < drawCount; ++i) commands[i] = ...; 10 | // Buffer* buffer = ...; 11 | // buffer->writeToGPU(0, sizeof(DrawElementsIndirectCommand) * drawCount, commands.data()); 12 | // cmdList.bindBuffer(GL_DRAW_INDIRECT_BUFFER, buffer->internal_getGLName()); 13 | // cmdList.multiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, drawCount, 0); 14 | // 15 | struct DrawElementsIndirectCommand { 16 | uint32 count; 17 | uint32 instanceCount; 18 | uint32 firstIndex; 19 | int32 baseVertex; 20 | uint32 baseInstance; 21 | }; 22 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/rhi/render_commands.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/gl_live_objects.h" 4 | 5 | #include "badger/types/int_types.h" 6 | #include 7 | 8 | namespace pathos { 9 | 10 | struct RenderCommandBase; 11 | union RenderCommandPacketUnion; 12 | 13 | typedef void (APIENTRYP PFN_EXECUTE)(const RenderCommandBase* __restrict params); 14 | 15 | struct RenderCommandBase { 16 | PFN_EXECUTE pfn_execute; 17 | }; 18 | 19 | #include "render_commands.generated.h" 20 | 21 | } 22 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/actor_component.cpp: -------------------------------------------------------------------------------- 1 | #include "actor_component.h" 2 | #include "actor.h" 3 | 4 | namespace pathos { 5 | 6 | void ActorComponent::unregisterFromParent() { 7 | if (owner != nullptr) { 8 | owner->unregisterComponent(this); 9 | } 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/directional_light_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | #include "directional_light_component.h" 5 | 6 | namespace pathos { 7 | 8 | class DirectionalLightActor : public Actor { 9 | 10 | public: 11 | DirectionalLightActor() { 12 | lightComponent = createDefaultComponent(); 13 | 14 | setAsRootComponent(lightComponent); 15 | } 16 | 17 | void setDirection(const vector3& direction) { lightComponent->direction = glm::normalize(direction); } 18 | void setColor(const vector3& color) { lightComponent->color = color; } 19 | void setIlluminance(float illuminance) { lightComponent->illuminance = illuminance; } 20 | 21 | void setColorAndIlluminance(const vector3& color, float illuminance) { 22 | lightComponent->color = color; 23 | lightComponent->illuminance = illuminance; 24 | } 25 | 26 | private: 27 | DirectionalLightComponent* lightComponent; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/landscape_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "actor.h" 4 | 5 | namespace pathos { 6 | 7 | class LandscapeComponent; 8 | struct ImageBlob; 9 | 10 | // Specialized actor for landscape mesh. 11 | class LandscapeActor : public Actor { 12 | 13 | public: 14 | LandscapeActor(); 15 | 16 | void initializeSectors(float inSizeX, float inSizeY, int32 inCountX, int32 inCountY); 17 | 18 | void initializeHeightMap(ImageBlob* heightMapBlob); 19 | 20 | float getLandscapeY(float x, float z) const; 21 | 22 | vector2 getLandscapeUV(float x, float z) const; 23 | 24 | inline LandscapeComponent* getLandscapeComponent() const { return landscapeComponent; } 25 | 26 | public: 27 | virtual void onSpawn() override; 28 | virtual void onDestroy() override; 29 | virtual void onTick(float deltaSeconds) override; 30 | 31 | private: 32 | LandscapeComponent* landscapeComponent; 33 | 34 | }; 35 | 36 | } 37 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/reflection_probe_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "reflection_probe_component.h" 4 | 5 | namespace pathos { 6 | 7 | class ReflectionProbeActor : public Actor { 8 | 9 | public: 10 | ReflectionProbeActor() { 11 | probeComponent = createDefaultComponent(); 12 | setAsRootComponent(probeComponent); 13 | } 14 | 15 | virtual void onSpawn() override; 16 | virtual void onDestroy() override; 17 | 18 | void captureScene(); 19 | 20 | void setCaptureRadius(float radius) { probeComponent->captureRadius = radius; } 21 | 22 | inline ReflectionProbeComponent* getProbeComponent() const { return probeComponent; } 23 | 24 | inline uint32 internal_getUpdatePhase() const { return updatePhase; } 25 | 26 | public: 27 | bool bUpdateEveryFrame = true; 28 | float lastUpdateTime = -1.0f; 29 | 30 | private: 31 | ReflectionProbeComponent* probeComponent; 32 | uint32 updatePhase = 0; 33 | 34 | }; 35 | 36 | } 37 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/scene_capture_component.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/gl_handles.h" 4 | #include "pathos/scene/scene_component.h" 5 | 6 | #include 7 | 8 | namespace pathos { 9 | 10 | class SceneComponent; 11 | class RenderTarget2D; 12 | 13 | // Captures the scene at its current location and rotation, and then write the result to a render target. 14 | // Basically it performs whole scene rendering again. 15 | class SceneCaptureComponent : public SceneComponent { 16 | 17 | public: 18 | SceneCaptureComponent() = default; 19 | virtual ~SceneCaptureComponent() = default; 20 | 21 | void captureScene(); 22 | 23 | public: 24 | float fovY = 60.0f; // in degrees 25 | float zNear = 0.01f; 26 | float zFar = 10000.0f; 27 | RenderTarget2D* renderTarget = nullptr; 28 | bool captureHDR = true; // Ignored if render target has depth format. 29 | 30 | private: 31 | std::vector actorsToCapture; 32 | uint32 sceneCaptureFrameNumber = 0; 33 | 34 | }; 35 | 36 | } 37 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/scene_render_settings.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | #include "pathos/render/postprocessing/anti_aliasing.h" 5 | 6 | namespace pathos { 7 | 8 | class RenderTargetView; 9 | 10 | struct SceneRenderSettings { 11 | 12 | bool isValid() const { 13 | return (sceneWidth != 0 && sceneHeight != 0); 14 | } 15 | 16 | uint32 sceneWidth = 0; 17 | uint32 sceneHeight = 0; 18 | uint32 frameCounter = 0; 19 | bool enablePostProcess = true; 20 | 21 | RenderTargetView* finalRenderTarget = nullptr; 22 | 23 | // For probe lighting. Convert and write linear sceneDepth. 24 | // Note that this texture actually has a color format. 25 | RenderTargetView* finalDepthTarget = nullptr; 26 | 27 | }; 28 | 29 | } 30 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/sky_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | 5 | // Spawn a sky actor in the world and it will automatically control sky lighting. 6 | // If multiple sky actors are spawned, only one of them contributes to sky lighting. 7 | // See SceneRenderer::renderScene() for the priority between sky types. 8 | 9 | namespace pathos { 10 | 11 | // Just a marker class. 12 | class SkyActor : public Actor { 13 | // 14 | }; 15 | 16 | } 17 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/sky_atmosphere_actor.h: -------------------------------------------------------------------------------- 1 | // Simulates the Earth's atmospheric scattering. 2 | // Currently no controls, just adapt to current Sun light settings. 3 | 4 | #pragma once 5 | 6 | #include "pathos/scene/sky_actor.h" 7 | #include "pathos/scene/sky_atmosphere_component.h" 8 | 9 | namespace pathos { 10 | 11 | class SkyAtmosphereActor : public SkyActor { 12 | 13 | public: 14 | SkyAtmosphereActor() { 15 | component = createDefaultComponent(); 16 | setAsRootComponent(component); 17 | } 18 | 19 | SkyAtmosphereComponent* getSkyComponent() const { return component; } 20 | 21 | private: 22 | SkyAtmosphereComponent* component; 23 | 24 | }; 25 | 26 | } 27 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/sky_common.cpp: -------------------------------------------------------------------------------- 1 | #include "sky_common.h" 2 | #include "pathos/console.h" 3 | 4 | #include "badger/math/minmax.h" 5 | 6 | namespace pathos { 7 | 8 | static ConsoleVariable cvar_skyLightingUpdateMode("r.skyLightingUpdateMode", 1, "0 = disable, 1 = progressive, 2 = every frame"); 9 | 10 | ESkyLightingUpdateMode getSkyLightingUpdateMode() { 11 | int32 value = cvar_skyLightingUpdateMode.getInt(); 12 | value = badger::clamp(0, value, 2); 13 | return (ESkyLightingUpdateMode)value; 14 | } 15 | 16 | pathos::ESkyLightingUpdatePhase getNextSkyLightingUpdatePhase(ESkyLightingUpdatePhase current) { 17 | current = (ESkyLightingUpdatePhase)((uint32)current + 1); 18 | if (current == ESkyLightingUpdatePhase::MAX) { 19 | current = (ESkyLightingUpdatePhase)0; 20 | } 21 | return current; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/sky_common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace pathos { 4 | 5 | enum class ESkyLightingUpdatePhase : uint32 { 6 | RenderFacePosX = 0, 7 | RenderFaceNegX = 1, 8 | RenderFacePosY = 2, 9 | RenderFaceNegY = 3, 10 | RenderFacePosZ = 4, 11 | RenderFaceNegZ = 5, 12 | GenerateMips = 6, 13 | DiffuseSH = 7, 14 | SpecularFilter = 8, 15 | MAX = 9, 16 | }; 17 | 18 | enum class ESkyLightingUpdateMode : uint32 { 19 | Disabled = 0, 20 | Progressive = 1, 21 | EveryFrame = 2, 22 | }; 23 | 24 | ESkyLightingUpdateMode getSkyLightingUpdateMode(); 25 | 26 | ESkyLightingUpdatePhase getNextSkyLightingUpdatePhase(ESkyLightingUpdatePhase current); 27 | 28 | } 29 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/sky_panorama_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "sky_actor.h" 4 | #include "sky_panorama_component.h" 5 | #include "pathos/rhi/gl_handles.h" 6 | 7 | namespace pathos { 8 | 9 | class Texture; 10 | 11 | // Use panorama (i.e., equirectangular map) texture as sky. 12 | class PanoramaSkyActor : public SkyActor { 13 | 14 | public: 15 | PanoramaSkyActor() { 16 | component = createDefaultComponent(); 17 | setAsRootComponent(component); 18 | } 19 | 20 | void setTexture(Texture* texture) { 21 | component->setTexture(texture); 22 | } 23 | 24 | PanoramaSkyComponent* getSkyComponent() const { return component; } 25 | 26 | private: 27 | PanoramaSkyComponent* component; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/skybox_actor.cpp: -------------------------------------------------------------------------------- 1 | #include "skybox_actor.h" 2 | 3 | namespace pathos { 4 | 5 | void SkyboxActor::setCubemapTexture(Texture* inTexture, float inLod) { 6 | component->setCubemapTexture(inTexture); 7 | component->setCubemapLOD(inLod); 8 | component->bUseCubemapTexture = true; 9 | } 10 | 11 | void SkyboxActor::setIntensityMultiplier(float multiplier) { 12 | component->setIntensityMultiplier(multiplier); 13 | } 14 | 15 | void SkyboxActor::setSkyboxMaterial(assetPtr material) { 16 | component->setSkyboxMaterial(material); 17 | component->bUseCubemapTexture = false; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/skybox_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/sky_actor.h" 4 | #include "pathos/scene/skybox_component.h" 5 | #include "pathos/smart_pointer.h" 6 | 7 | namespace pathos { 8 | 9 | class Texture; 10 | class Material; 11 | 12 | // Render sky with cubemap texture or sky material. 13 | // If both are set, the one that is most recently set is used. 14 | class SkyboxActor : public SkyActor { 15 | 16 | public: 17 | SkyboxActor() { 18 | component = createDefaultComponent(); 19 | setAsRootComponent(component); 20 | } 21 | 22 | void setCubemapTexture(Texture* texture, float lod = 0.0f); 23 | 24 | void setIntensityMultiplier(float multiplier); 25 | 26 | void setSkyboxMaterial(assetPtr material); 27 | 28 | inline SkyboxComponent* getSkyComponent() const { return component; } 29 | 30 | private: 31 | SkyboxComponent* component; 32 | }; 33 | 34 | } 35 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/scene/static_mesh_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "static_mesh_component.h" 4 | #include "pathos/scene/actor.h" 5 | 6 | namespace pathos { 7 | 8 | class StaticMesh; 9 | 10 | class StaticMeshActor : public Actor { 11 | 12 | public: 13 | StaticMeshActor() { 14 | meshComponent = createDefaultComponent(); 15 | 16 | setAsRootComponent(meshComponent); 17 | } 18 | 19 | void setStaticMesh(assetPtr inMesh) { 20 | meshComponent->setStaticMesh(inMesh); 21 | } 22 | 23 | inline StaticMeshComponent* getStaticMeshComponent() const { return meshComponent; } 24 | inline assetPtr getStaticMesh() const { return meshComponent->getStaticMesh(); } 25 | 26 | private: 27 | StaticMeshComponent* meshComponent; 28 | 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/text/text_actor.cpp: -------------------------------------------------------------------------------- 1 | #include "text_actor.h" 2 | #include "pathos/text/text_component.h" 3 | 4 | namespace pathos { 5 | 6 | TextMeshActor::TextMeshActor() { 7 | textComponent = createDefaultComponent(); 8 | setAsRootComponent(textComponent); 9 | } 10 | 11 | void TextMeshActor::setText(const wchar_t* text) { 12 | textComponent->setText(text); 13 | } 14 | 15 | void TextMeshActor::setColor(float r, float g, float b) { 16 | textComponent->setColor(r, g, b); 17 | } 18 | 19 | void TextMeshActor::setFont(const std::string& tag) { 20 | textComponent->setFont(tag); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/text/text_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | #include 5 | 6 | namespace pathos { 7 | 8 | class TextMeshComponent; 9 | 10 | class TextMeshActor : public Actor { 11 | 12 | public: 13 | TextMeshActor(); 14 | 15 | void setText(const wchar_t* text); 16 | void setColor(float r, float g, float b); 17 | void setFont(const std::string& tag); 18 | 19 | private: 20 | TextMeshComponent* textComponent; 21 | 22 | }; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/text/text_component.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/text/text_geometry.h" 4 | #include "pathos/text/font_mgr.h" 5 | #include "pathos/material/material.h" 6 | #include "pathos/scene/scene_component.h" 7 | #include "pathos/smart_pointer.h" 8 | 9 | namespace pathos { 10 | 11 | class TextMeshComponent : public SceneComponent { 12 | 13 | public: 14 | TextMeshComponent(); 15 | ~TextMeshComponent() = default; 16 | 17 | virtual void createRenderProxy(SceneProxy* scene) override; 18 | virtual void updateDynamicData_renderThread(RenderCommandList& cmdList) override; 19 | 20 | void setText(const wchar_t* text); 21 | void setColor(float r, float g, float b); 22 | void setFont(const std::string& tag); 23 | 24 | private: 25 | std::wstring text; 26 | uniquePtr geom; 27 | assetPtr material; 28 | FontDesc fontDesc; 29 | 30 | bool dynamicDataDirty = false; 31 | 32 | }; 33 | 34 | } 35 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/text/text_geometry.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/gl_handles.h" 4 | #include "pathos/mesh/static_mesh.h" 5 | #include "pathos/scene/scene_component.h" 6 | #include "pathos/text/font_texture_cache.h" 7 | #include "pathos/rhi/render_command_list.h" 8 | 9 | #include 10 | #include 11 | 12 | namespace pathos { 13 | 14 | class TextGeometry : public MeshGeometry { 15 | 16 | public: 17 | TextGeometry(); 18 | 19 | uint32 getTextWidth(FontTextureCache& cache, const std::wstring& text) const; 20 | 21 | // Update vertex and index buffers for new text. 22 | void configure(RenderCommandList& cmdList, FontTextureCache& cache, const std::wstring& text); 23 | 24 | }; 25 | 26 | } 27 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/engine_thread.cpp: -------------------------------------------------------------------------------- 1 | #include "engine_thread.h" 2 | 3 | namespace pathos { 4 | 5 | PlatformThreadId gMainThreadId = (PlatformThreadId)(-1); 6 | PlatformThreadId gRenderThreadId = (PlatformThreadId)(-1); 7 | 8 | } 9 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/engine_thread.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "badger/types/int_types.h" 4 | #include "badger/assertion/assertion.h" 5 | #include "badger/system/cpu.h" 6 | 7 | namespace pathos { 8 | 9 | extern PlatformThreadId gMainThreadId; 10 | extern PlatformThreadId gRenderThreadId; 11 | 12 | inline bool isInMainThread() { 13 | CHECK(gMainThreadId != 0); 14 | return (gMainThreadId == CPU::getCurrentThreadId()); 15 | } 16 | 17 | inline bool isInRenderThread() { 18 | CHECK(gRenderThreadId != 0); 19 | return (gRenderThreadId == CPU::getCurrentThreadId()); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/engine_util.cpp: -------------------------------------------------------------------------------- 1 | #include "engine_util.h" 2 | #include "log.h" 3 | 4 | namespace pathos { 5 | 6 | void checkFramebufferStatus(RenderCommandList& cmdList, GLuint fbo, const char* message) { 7 | struct FBOStatusQuery { 8 | GLenum* completeness; 9 | const char* message; 10 | }; 11 | 12 | FBOStatusQuery query; 13 | query.completeness = ALLOC_RENDER_PROXY(cmdList.sceneProxy); 14 | query.message = ALLOC_PDO_STRING(cmdList.sceneProxy->renderProxyAllocator, message); 15 | cmdList.checkNamedFramebufferStatus(fbo, GL_DRAW_FRAMEBUFFER, query.completeness); 16 | 17 | cmdList.registerHook([query](RenderCommandList& cmdList) { 18 | if (*(query.completeness) != GL_FRAMEBUFFER_COMPLETE) { 19 | LOG(LogFatal, "Failed to initialize fbo: %s", query.message != nullptr ? query.message : ""); 20 | CHECK_NO_ENTRY(); 21 | } 22 | }); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/os_util.cpp: -------------------------------------------------------------------------------- 1 | #include "os_util.h" 2 | 3 | #include "badger/system/platform.h" 4 | 5 | #if PLATFORM_WINDOWS 6 | #include 7 | // https://stackoverflow.com/questions/14762456/getclipboarddatacf-text 8 | static std::wstring getWin32ClipboardText() { 9 | if (!::OpenClipboard(nullptr)) { 10 | return L""; 11 | } 12 | HANDLE hData = ::GetClipboardData(CF_UNICODETEXT); 13 | if (hData == NULL) { 14 | return L""; 15 | } 16 | wchar_t* pszText = static_cast(::GlobalLock(hData)); 17 | if (pszText == NULL) { 18 | return L""; 19 | } 20 | std::wstring msg(pszText); 21 | ::GlobalUnlock(hData); 22 | ::CloseClipboard(); 23 | return msg; 24 | } 25 | #endif 26 | 27 | namespace pathos { 28 | 29 | bool getOSClipboardUnicodeText(std::wstring& outText) { 30 | #if PLATFORM_WINDOWS 31 | outText = getWin32ClipboardText(); 32 | return outText.size() > 0; 33 | #else 34 | #error Not implemented. 35 | return false; 36 | #endif 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/os_util.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace pathos { 4 | 5 | // Get text from OS clipboard. 6 | // @return true if successful. false if failed to access the clipboard for any reason. 7 | bool getOSClipboardUnicodeText(std::wstring& outText); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/renderdoc_integration.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define WIN32 4 | #include "renderdoc/api/app/renderdoc_app.h" 5 | 6 | namespace pathos { 7 | 8 | class RenderDocIntegration { 9 | 10 | public: 11 | static RenderDocIntegration& get(); 12 | 13 | private: 14 | RenderDocIntegration(); 15 | ~RenderDocIntegration(); 16 | 17 | RenderDocIntegration(const RenderDocIntegration&) = delete; 18 | RenderDocIntegration& operator=(const RenderDocIntegration&) = delete; 19 | 20 | public: 21 | bool findInjectedDLL(); 22 | void captureFrame(); 23 | 24 | private: 25 | RENDERDOC_API_1_4_1* api; 26 | 27 | }; 28 | 29 | } 30 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/resource_finder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace pathos { 7 | 8 | // Given a path, searches for a matching full path. 9 | class ResourceFinder { 10 | public: 11 | static ResourceFinder& get(); 12 | // register a directory 13 | void add(const std::string& directory); 14 | // Returns empty string if not found 15 | std::string find(const std::string& subpath); 16 | private: 17 | ResourceFinder(); 18 | ResourceFinder(const ResourceFinder& other) = delete; 19 | ResourceFinder(ResourceFinder&& rhs) = delete; 20 | std::vector directories; 21 | }; 22 | 23 | } -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/string_conversion.cpp: -------------------------------------------------------------------------------- 1 | #include "string_conversion.h" 2 | 3 | #include 4 | #include 5 | 6 | namespace pathos { 7 | 8 | void MBCS_TO_WCHAR(const std::string& inStr, std::wstring& outStr) 9 | { 10 | int size = ::MultiByteToWideChar(CP_ACP, 0, inStr.data(), (int)inStr.size(), NULL, 0); 11 | outStr.assign(size, 0); 12 | ::MultiByteToWideChar(CP_ACP, 0, inStr.data(), (int)inStr.size(), const_cast(outStr.data()), size); 13 | } 14 | 15 | void WCHAR_TO_MBCS(const std::wstring& inStr, std::string& outStr) 16 | { 17 | int size = ::WideCharToMultiByte(CP_ACP, 0, inStr.data(), (int)inStr.size(), NULL, 0, NULL, NULL); 18 | outStr.assign(size, 0); 19 | ::WideCharToMultiByte(CP_ACP, 0, inStr.data(), (int)inStr.size(), const_cast(outStr.data()), size, NULL, NULL); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pathos/util/string_conversion.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace pathos { 6 | 7 | void MBCS_TO_WCHAR(const std::string& inStr, std::wstring& outStr); 8 | 9 | void WCHAR_TO_MBCS(const std::wstring& inStr, std::string& outStr); 10 | 11 | } 12 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pch.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/pch.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // STL 4 | #include 5 | #include 6 | #include 7 | 8 | // Very long files 9 | #include "pathos/rhi/render_command_list.h" 10 | #include "pathos/rhi/render_commands.h" 11 | 12 | #include "pathos/smart_pointer.h" 13 | 14 | #include "badger/types/int_types.h" 15 | #include "badger/types/vector_types.h" 16 | #include "badger/types/matrix_types.h" 17 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/thirdparty/tinygltf.cpp: -------------------------------------------------------------------------------- 1 | #define TINYGLTF_IMPLEMENTATION 2 | #define STB_IMAGE_IMPLEMENTATION 3 | #define STB_IMAGE_WRITE_IMPLEMENTATION 4 | #define STBI_MSC_SECURE_CRT 5 | // #define TINYGLTF_NOEXCEPTION // optional. disable exception handling. 6 | #include "tiny_gltf.h" 7 | -------------------------------------------------------------------------------- /projects/PathosEngine/src/thirdparty/tinyobjloader.cpp: -------------------------------------------------------------------------------- 1 | #define TINYOBJLOADER_IMPLEMENTATION 2 | #include "tiny_obj_loader.h" 3 | 4 | // https://github.com/tinyobjloader/tinyobjloader/commit/2f947710aeedea2089ade2b62ef669521d90f2ef 5 | -------------------------------------------------------------------------------- /projects/Test_DeferredRenderer/src/csm_debugger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/camera.h" 4 | #include "pathos/scene/static_mesh_actor.h" 5 | #include "pathos/mesh/geometry_procedural.h" 6 | #include "pathos/smart_pointer.h" 7 | using namespace pathos; 8 | 9 | #include "badger/types/vector_types.h" 10 | 11 | class CSMDebugger : public StaticMeshActor { 12 | 13 | public: 14 | CSMDebugger(); 15 | 16 | void drawCameraFrustum(const Camera& camera, const vector3& sunDirection); 17 | 18 | private: 19 | assetPtr G; 20 | assetPtr G2; 21 | 22 | }; 23 | -------------------------------------------------------------------------------- /projects/Test_DeferredRenderer/src/galaxy_gen.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/rhi/gl_handles.h" 4 | #include "pathos/rhi/render_command_list.h" 5 | using namespace pathos; 6 | 7 | namespace pathos { 8 | class OpenGLDevice; 9 | class PlaneGeometry; 10 | class Texture; 11 | } 12 | 13 | // Render skybox for world_rc1 14 | class GalaxyGenerator { 15 | 16 | public: 17 | static void renderStarField(Texture* texture, uint32 width, uint32 height, float dustIntensity); 18 | 19 | static void internal_createResources(OpenGLDevice* renderDevice, RenderCommandList& cmdList); 20 | static void internal_destroyResources(OpenGLDevice* renderDevice, RenderCommandList& cmdList); 21 | 22 | private: 23 | static GLuint dummyFBO; 24 | 25 | }; 26 | -------------------------------------------------------------------------------- /projects/Test_DeferredRenderer/src/player_controller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | using namespace pathos; 5 | 6 | class PlayerController : public Actor 7 | { 8 | 9 | public: 10 | virtual void onSpawn() override; 11 | virtual void onTick(float deltaSeconds) override; 12 | 13 | float speedScale = 1.0f; 14 | 15 | // movement (meters/sec) 16 | float speedRight = 2.0f; 17 | float speedForward = 2.0f; 18 | float speedUp = 2.0f; 19 | 20 | // rotation (degrees/sec) 21 | float speedYaw = 120.0f; 22 | float speedPitch = 120.0f; 23 | 24 | private: 25 | void setupInput(); 26 | 27 | bool rotateByMouse = false; 28 | 29 | }; 30 | -------------------------------------------------------------------------------- /projects/Test_DeferredRenderer/src/transform_test_actor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | using namespace pathos; 5 | 6 | #include 7 | 8 | namespace pathos { 9 | class StaticMeshComponent; 10 | } 11 | 12 | class TransformTestActor : public Actor { 13 | 14 | public: 15 | TransformTestActor(); 16 | 17 | void onTick(float deltaSeconds) override; 18 | 19 | private: 20 | StaticMeshComponent* root; 21 | std::vector stars; 22 | std::vector moons; 23 | 24 | }; 25 | -------------------------------------------------------------------------------- /projects/Test_DeferredRenderer/src/world_lightroom.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/world.h" 4 | using namespace pathos; 5 | 6 | namespace pathos { 7 | class GLTFLoader; 8 | class StaticMeshComponent; 9 | class IrradianceVolumeActor; 10 | } 11 | class PlayerController; 12 | 13 | class World_LightRoom : public World { 14 | 15 | public: 16 | void onInitialize() override; 17 | void onTick(float deltaSeconds) override; 18 | 19 | private: 20 | void onLoadGLTF(GLTFLoader* loader, uint64 payload); 21 | 22 | actorPtr playerController; 23 | StaticMeshComponent* ballComponent = nullptr; 24 | 25 | std::vector fractures; 26 | std::vector fractureOrigins; 27 | std::vector fractureTargets; 28 | 29 | std::vector leafComponents; 30 | std::vector leafOrigins; 31 | std::vector leafTargets; 32 | 33 | actorPtrList irradianceVolumes; 34 | }; 35 | -------------------------------------------------------------------------------- /projects/Test_DeferredRenderer/src/world_physics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/world.h" 4 | using namespace pathos; 5 | 6 | class World_Physics : public World { 7 | 8 | public: 9 | void onInitialize() override; 10 | void onTick(float deltaSeconds) override; 11 | 12 | private: 13 | // 14 | 15 | }; 16 | -------------------------------------------------------------------------------- /projects/Test_ModelViewer/src/main_modelviewer.cpp: -------------------------------------------------------------------------------- 1 | #include "world_modelviewer.h" 2 | 3 | #include "pathos/core_minimal.h" 4 | #include "pathos/gui/gui_window.h" 5 | #include "pathos/input/input_manager.h" 6 | using namespace pathos; 7 | 8 | const char* WINDOW_TITLE = "Model Viewer"; 9 | const int32 WINDOW_WIDTH = 1920; 10 | const int32 WINDOW_HEIGHT = 1080; 11 | const bool WINDOW_FULLSCREEN = false; 12 | 13 | int main(int argc, char** argv) { 14 | EngineConfig engineConfig; 15 | engineConfig.windowWidth = WINDOW_WIDTH; 16 | engineConfig.windowHeight = WINDOW_HEIGHT; 17 | engineConfig.fullscreen = WINDOW_FULLSCREEN; 18 | engineConfig.title = WINDOW_TITLE; 19 | Engine::init(argc, argv, engineConfig); 20 | 21 | World* world = new World_ModelViewer; 22 | gEngine->setWorld(world); 23 | 24 | gEngine->start(); 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /projects/Test_ModelViewer/src/player_controller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | using namespace pathos; 5 | 6 | // #todo: Eh... it's time to make this an engine-level class I guess? 7 | // Same controller code exist in every application projects... 8 | class PlayerController : public Actor { 9 | 10 | public: 11 | virtual void onSpawn() override; 12 | virtual void onTick(float deltaSeconds) override; 13 | 14 | public: 15 | // movement (meters/sec) 16 | float speedRight = 2.0f; 17 | float speedForward = 2.0f; 18 | float speedUp = 2.0f; 19 | 20 | // rotation (degrees/sec) 21 | float speedYaw = 120.0f; 22 | float speedPitch = 120.0f; 23 | 24 | private: 25 | void setupInput(); 26 | 27 | bool rotateByMouse = false; 28 | 29 | }; 30 | -------------------------------------------------------------------------------- /projects/Test_Physics/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "world_gjk.h" 2 | 3 | #include "pathos/core_minimal.h" 4 | #include "pathos/gui/gui_window.h" 5 | #include "pathos/input/input_manager.h" 6 | using namespace pathos; 7 | 8 | const char* WINDOW_TITLE = "Demo Application"; 9 | const int32 WINDOW_WIDTH = 1920; 10 | const int32 WINDOW_HEIGHT = 1080; 11 | const bool WINDOW_FULLSCREEN = false; 12 | 13 | int main(int argc, char** argv) { 14 | EngineConfig config; 15 | config.windowWidth = WINDOW_WIDTH; 16 | config.windowHeight = WINDOW_HEIGHT; 17 | config.fullscreen = WINDOW_FULLSCREEN; 18 | config.title = WINDOW_TITLE; 19 | Engine::init(argc, argv, config); 20 | 21 | World* world = new World_GJK; 22 | gEngine->setWorld(world); 23 | gEngine->start(); 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /projects/Test_Physics/src/player_controller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | #include "pathos/smart_pointer.h" 5 | using namespace pathos; 6 | 7 | class PlayerController : public Actor { 8 | 9 | public: 10 | virtual void onSpawn() override; 11 | virtual void onTick(float deltaSeconds) override; 12 | 13 | inline void setControlTarget(sharedPtr inTarget) { target = inTarget; } 14 | 15 | public: 16 | // movement (meters/sec) 17 | float speedRight = 2.0f; 18 | float speedForward = 2.0f; 19 | float speedUp = 2.0f; 20 | 21 | // rotation (degrees/sec) 22 | float speedYaw = 120.0f; 23 | float speedPitch = 120.0f; 24 | 25 | private: 26 | void setupInput(); 27 | 28 | sharedPtr target; 29 | 30 | }; 31 | -------------------------------------------------------------------------------- /projects/Test_Physics/src/world_gjk.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/engine.h" 4 | #include "pathos/scene/world.h" 5 | #include "pathos/smart_pointer.h" 6 | using namespace pathos; 7 | 8 | #include "badger/physics/shape.h" 9 | 10 | namespace pathos { 11 | class SkyAtmosphereActor; 12 | class DirectionalLightActor; 13 | class StaticMeshActor; 14 | class Material; 15 | } 16 | class PlayerController; 17 | 18 | class World_GJK : public World { 19 | 20 | public: 21 | virtual void onInitialize() override; 22 | virtual void onTick(float deltaSeconds) override; 23 | 24 | private: 25 | actorPtr controller; 26 | 27 | actorPtr modelA; 28 | actorPtr modelB; 29 | actorPtr arrow; 30 | 31 | badger::physics::Body bodyA; 32 | badger::physics::Body bodyB; 33 | 34 | assetPtr materialNoHit; 35 | assetPtr materialOnHit; 36 | 37 | }; 38 | -------------------------------------------------------------------------------- /projects/Test_RacingGame/src/main_racing_game.cpp: -------------------------------------------------------------------------------- 1 | #include "world/world_racing_title.h" 2 | #include "world/world_racing_game.h" 3 | 4 | #include "pathos/core_minimal.h" 5 | using namespace pathos; 6 | 7 | const char* WINDOW_TITLE = "Racing Game"; 8 | const int32 WINDOW_WIDTH = 1920; 9 | const int32 WINDOW_HEIGHT = 1080; 10 | const bool WINDOW_FULLSCREEN = false; 11 | 12 | int main(int argc, char** argv) { 13 | EngineConfig engineConfig; 14 | engineConfig.windowWidth = WINDOW_WIDTH; 15 | engineConfig.windowHeight = WINDOW_HEIGHT; 16 | engineConfig.fullscreen = WINDOW_FULLSCREEN; 17 | engineConfig.title = WINDOW_TITLE; 18 | Engine::init(argc, argv, engineConfig); 19 | 20 | World* startWorld = new World_RacingTitle; 21 | 22 | gEngine->setWorld(startWorld); 23 | gEngine->start(); 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /projects/Test_RacingGame/src/pathos_forward_decl.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Forward declarations for common types 4 | 5 | namespace pathos { 6 | class VolumetricCloudActor; 7 | class SkyAtmosphereActor; 8 | class SkyboxActor; 9 | class PanoramaSkyActor; 10 | class DirectionalLightActor; 11 | class PointLightActor; 12 | class StaticMeshActor; 13 | class StaticMesh; 14 | class Texture; 15 | class OBJLoader; 16 | } 17 | -------------------------------------------------------------------------------- /projects/Test_RacingGame/src/player_controller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace pathos { 4 | class LandscapeActor; 5 | } 6 | 7 | #include "pathos/scene/actor.h" 8 | using namespace pathos; 9 | 10 | class PlayerController : public Actor 11 | { 12 | 13 | public: 14 | virtual void onSpawn() override; 15 | virtual void onTick(float deltaSeconds) override; 16 | 17 | void setPlayerPawn(Actor* player); 18 | inline void setLandscape(LandscapeActor* inLandscape) { landscape = inLandscape; } 19 | void togglePhotoMode(); 20 | 21 | float cameraHeightOffset = 1.8f; 22 | float cameraForwardOffset = 3.0f; 23 | 24 | private: 25 | void setupInput(); 26 | void tickGameplay(float deltaSeconds); 27 | void tickPhotoMode(float deltaSeconds); 28 | 29 | Actor* playerPawn = nullptr; 30 | LandscapeActor* landscape = nullptr; 31 | bool inPhotoMode = false; 32 | 33 | // gameplay 34 | Rotator pawnRotation; 35 | float linearSpeed = 0.0f; 36 | 37 | // photo mode 38 | bool rotateByMouse = false; 39 | 40 | }; 41 | -------------------------------------------------------------------------------- /projects/Test_RacingGame/src/widget/base_widget.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/overlay/display_object.h" 4 | using namespace pathos; 5 | 6 | namespace pathos { 7 | class InputManager; 8 | } 9 | 10 | class BaseWidget : public DisplayObject2D { 11 | 12 | public: 13 | BaseWidget(); 14 | virtual ~BaseWidget(); 15 | 16 | // true: visible and receive input. 17 | // false: invisible and ignore input. 18 | void setWidgetEnabled(bool value); 19 | 20 | void fitToScreenSize(); 21 | 22 | protected: 23 | InputManager* inputManager = nullptr; 24 | 25 | uint32 baseResolutionX, baseResolutionY; 26 | 27 | }; 28 | -------------------------------------------------------------------------------- /projects/Test_RacingGame/src/widget/title_widget.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "base_widget.h" 4 | 5 | #include "pathos/overlay/display_object.h" 6 | using namespace pathos; 7 | 8 | #include 9 | 10 | namespace pathos { 11 | class Label; 12 | } 13 | class World_RacingTitle; 14 | 15 | class TitleWidget : public BaseWidget { 16 | 17 | public: 18 | TitleWidget(World_RacingTitle* inOwnerWorld); 19 | 20 | private: 21 | void createUI(); 22 | void bindInput(); 23 | void updateUI(); 24 | 25 | World_RacingTitle* ownerWorld = nullptr; 26 | 27 | Label* startLabel = nullptr; 28 | Label* optionsLabel = nullptr; 29 | Label* exitLabel = nullptr; 30 | 31 | int32 selectedLabel = -1; 32 | std::vector labels; 33 | 34 | }; 35 | -------------------------------------------------------------------------------- /projects/Test_RacingGame/src/world/world_racing_title.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/world.h" 4 | #include "pathos/smart_pointer.h" 5 | using namespace pathos; 6 | 7 | class TitleWidget; 8 | class GameOptionsWidget; 9 | #include "pathos_forward_decl.h" 10 | 11 | class World_RacingTitle : public World { 12 | 13 | protected: 14 | // BEGIN_INTERFACE: World 15 | virtual void onInitialize() override; 16 | virtual void onDestroy() override; 17 | virtual void onTick(float deltaSeconds) override; 18 | // END_INTERFACE: World 19 | 20 | // Events 21 | public: 22 | void onStartGameWorld(); 23 | void onOpenOptionsWidget(); 24 | void onCloseOptionsWidget(); 25 | 26 | private: 27 | void loadScene(); 28 | void createWidgets(); 29 | 30 | actorPtr skybox; 31 | actorPtr sun; 32 | 33 | TitleWidget* titleWidget = nullptr; 34 | GameOptionsWidget* optionsWidget = nullptr; 35 | }; 36 | -------------------------------------------------------------------------------- /projects/Test_SkeletalAnimation/src/animation.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "assimp/scene.h" 4 | 5 | #include 6 | #include 7 | 8 | namespace pathos { 9 | 10 | class SkeletalAnimation { 11 | 12 | public: 13 | SkeletalAnimation(aiAnimation* anim) { 14 | this->anim = anim; 15 | } 16 | 17 | inline const std::string getName() const { return std::string(anim->mName.C_Str()); } 18 | double getLength() const { return anim->mDuration; } 19 | 20 | // TODO: encalsulate aiAnimation 21 | //private: 22 | public: 23 | aiAnimation* anim; 24 | 25 | }; 26 | 27 | } -------------------------------------------------------------------------------- /projects/Test_SkeletalAnimation/src/bone.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace pathos { 7 | 8 | struct Bone { 9 | 10 | public: 11 | std::string name; 12 | std::vector weights; 13 | std::vector vertexIDs; 14 | glm::mat4 offset; 15 | glm::mat4 finalTransform; 16 | }; 17 | 18 | } -------------------------------------------------------------------------------- /projects/Test_SkeletalAnimation/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "world2.h" 2 | #include "pathos/core_minimal.h" 3 | using namespace std; 4 | using namespace pathos; 5 | 6 | constexpr int32 WINDOW_WIDTH = 1920; 7 | constexpr int32 WINDOW_HEIGHT = 1080; 8 | constexpr char* WINDOW_TITLE = "Test: Skeletal Animation"; 9 | 10 | int main(int argc, char** argv) { 11 | EngineConfig conf; 12 | conf.windowWidth = WINDOW_WIDTH; 13 | conf.windowHeight = WINDOW_HEIGHT; 14 | conf.title = WINDOW_TITLE; 15 | Engine::init(argc, argv, conf); 16 | 17 | World* world2 = new World2; 18 | 19 | gEngine->setWorld(world2); 20 | gEngine->start(); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /projects/Test_SkeletalAnimation/src/player_controller.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pathos/scene/actor.h" 4 | using namespace pathos; 5 | 6 | class PlayerController : public Actor 7 | { 8 | 9 | public: 10 | virtual void onSpawn() override; 11 | virtual void onTick(float deltaSeconds) override; 12 | 13 | private: 14 | void setupInput(); 15 | 16 | bool rotateByMouse = false; 17 | 18 | }; 19 | -------------------------------------------------------------------------------- /projects/UnitTest/TestCamera.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "CppUnitTest.h" 3 | 4 | #include "pathos/engine.h" 5 | #include "pathos/scene/camera.h" 6 | 7 | using namespace Microsoft::VisualStudio::CppUnitTestFramework; 8 | using namespace pathos; 9 | 10 | namespace UnitTest 11 | { 12 | TEST_CLASS(TestCamera) 13 | { 14 | public: 15 | 16 | TEST_METHOD(TestEyeVector) 17 | { 18 | PerspectiveLens lens(60.0f, 1.0f, 0.1f, 5000.0f); 19 | Camera camera(lens); 20 | camera.lookAt(vector3(0.0f, 0.0f, 10.0f), vector3(0.0f, 0.0f, 0.0f), vector3(0.f, 1.0f, 0.0f)); 21 | 22 | bool equals = camera.getEyeVector() == vector3(0.0f, 0.0f, -1.0f); 23 | 24 | Assert::IsTrue(equals, L"Camera eye vector is wrong"); 25 | } 26 | }; 27 | } 28 | -------------------------------------------------------------------------------- /projects/UnitTest/pch.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | -------------------------------------------------------------------------------- /projects/UnitTest/pch.h: -------------------------------------------------------------------------------- 1 | #ifndef PCH_H 2 | #define PCH_H 3 | 4 | // STL 5 | #include 6 | #include 7 | #include 8 | 9 | // Very long files 10 | #include "pathos/rhi/render_command_list.h" 11 | #include "pathos/rhi/render_commands.h" 12 | 13 | #include "pathos/smart_pointer.h" 14 | 15 | #include "badger/types/int_types.h" 16 | #include "badger/types/vector_types.h" 17 | #include "badger/types/matrix_types.h" 18 | 19 | #endif //PCH_H 20 | -------------------------------------------------------------------------------- /resources/common/noiseErosion.tga: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:e279f30ca7d101a6b02282929127fb139f3306b38a1ae80b41f1a69d8d285d41 3 | size 131111 4 | -------------------------------------------------------------------------------- /resources/common/noiseErosionPacked.tga: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:58401dab4b1e0f1aba80e5b06933d8e7768787d3c465a219589cec99872cb230 3 | size 131111 4 | -------------------------------------------------------------------------------- /resources/common/noiseShape.tga: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:c5e19ba815b68e3de245f4152a4a82df6da5331449e0cef33193a1d7443b6999 3 | size 8388647 4 | -------------------------------------------------------------------------------- /resources/common/noiseShapePacked.tga: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:2611def30db5dc8e1b8c1067985021780f53817971c220c03951d284a0dec29e 3 | size 8388647 4 | -------------------------------------------------------------------------------- /resources/fonts/BMJUA.ttf: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:9d33c1fcb5c9726f10c25ec503d94843208c5e553a0b276f7e71d3556519645d 3 | size 1560072 4 | -------------------------------------------------------------------------------- /resources/fonts/consola.ttf: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:45c14a49e0ba2edc00b72afad9a930cad5c1b9a93323b239a8c308efc5a65e8e 3 | size 358256 4 | -------------------------------------------------------------------------------- /resources/fonts/consolab.ttf: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:5c27a540c51a0e60b2caa4e9f6c9164fde89a9fdc560747bfa1658f6e556cf61 3 | size 368520 4 | -------------------------------------------------------------------------------- /resources/fonts/consolai.ttf: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:18db132c539323badaf0e1c9ceffa497e1996946a8faac26cc5fbe6fc8233314 3 | size 364864 4 | -------------------------------------------------------------------------------- /resources/fonts/consolaz.ttf: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:fc9e9f0b6ae6d068b01e1511e475b508e15799529f53679f1e927f5418040c3f 3 | size 375056 4 | -------------------------------------------------------------------------------- /resources/lightroom/LightRoom.bin: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:c1d891ca31d75a0b112953581ef87c32be1ba80b8c00b83ab9be54a1c3b52d9d 3 | size 8196120 4 | -------------------------------------------------------------------------------- /resources/lightroom/LightRoom.gltf: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:6cab5bd2f48ca394ab986be07f9981babd82db8cfee2c29d932335745c1f6899 3 | size 1922913 4 | -------------------------------------------------------------------------------- /resources/models/animtest/animtest.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/resources/models/animtest/animtest.blend -------------------------------------------------------------------------------- /resources/models/animtest/animtest.blend1: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/resources/models/animtest/animtest.blend1 -------------------------------------------------------------------------------- /resources/models/animtest/animtest.dae: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:176fd8332905fe6d26a2e9e460e29843d2ed002ab7ddfacd4b9b66fc896a6830 3 | size 36702 4 | -------------------------------------------------------------------------------- /resources/racing_game/korea_albedo.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:d10462427d1fcefb99bc4bf81b28ca206a74733ca9fae1f7517d67aa158111b8 3 | size 2725042 4 | -------------------------------------------------------------------------------- /resources/racing_game/korea_height.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:8e202e57a6eddd27afa476f813844135f4ac11578c1924149cbb426e6aa90ee1 3 | size 2098559 4 | -------------------------------------------------------------------------------- /resources/racing_game/korea_normal.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:34252dd38c2d79d12a6e3c384c8af61963a7e210acdda91f6bae7e9c23b495ae 3 | size 937288 4 | -------------------------------------------------------------------------------- /resources/racing_game/landscape.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:e4b746ee26495bf31dd8433e0c039a733848f827c0a9981f2630fcda79dd6f20 3 | size 4222142 4 | -------------------------------------------------------------------------------- /resources/racing_game/title_scene.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "TitleScene", 3 | "skybox": { 4 | "name": "Skybox", 5 | "flipPreference": "hlsl", 6 | "textures": [ 7 | "resources/skybox/cubemap1/pos_x.jpg", "resources/skybox/cubemap1/neg_x.jpg", 8 | "resources/skybox/cubemap1/pos_y.jpg", "resources/skybox/cubemap1/neg_y.jpg", 9 | "resources/skybox/cubemap1/pos_z.jpg", "resources/skybox/cubemap1/neg_z.jpg" 10 | ], 11 | "generateMipmaps": true 12 | }, 13 | "directionalLight": [ 14 | { 15 | "name": "Sun", 16 | "direction": [0, -0.4, -1], 17 | "color": [1.0, 1.0, 1.0], 18 | "illuminance": 5.0 19 | } 20 | ] 21 | } -------------------------------------------------------------------------------- /resources/references.txt: -------------------------------------------------------------------------------- 1 | [cubemap textures] 2 | http://www.thegamecreators.com/ 3 | 4 | [normal map textures] 5 | http://opengameart.org/content/50-free-textures-4-normalmaps 6 | 7 | [pbr materials] 8 | https://freepbr.com/ -------------------------------------------------------------------------------- /resources/render_challenge_1/A_Brick.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:6e831500410f1e93c9222b4801022354ea083af08dcecc493681f1c0179b047e 3 | size 616529 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/A_Tower.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:cdf1157e127c71e8356a4226608c48f569bce41c3a31cc6b3533a8be41659192 3 | size 23246 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/M_Brick.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:1bcd48a5fda8d40057ff7a666543d08a6f2351415238a6f4cafb82684d8cb677 3 | size 624475 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/M_Tower.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:0e070843bb69bb683f654e75ee38afd1b9271d0c390f238675b7d16db1f453aa 3 | size 22251 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/N_Brick.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:739469a89fcd674f5720be4eb7af4a0c94d219281b827074deaf75a21663cb72 3 | size 5115293 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/N_Tower.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:bb6f656d6bd5cc5f9639e73c748db5a7933a8ff52a8667f2382ffa3c6f6f0e35 3 | size 28346851 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/R_Brick.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:0e070843bb69bb683f654e75ee38afd1b9271d0c390f238675b7d16db1f453aa 3 | size 22251 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/R_Tower.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:1463b6e891a9444949ed2ee7efeb19dc4982a1faeb9dc7beb594df7c70f9767e 3 | size 23247 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/T_Brick.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:cf75ea27f9be6826053ff5774e65b82d4cf0cd615e94713adcd4d5217ba26e88 3 | size 589117 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/T_Tower.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:64d1d55c480edcc728153c0ae85f7ef98fbd23eda5f7523303eb49376fbcc7b9 3 | size 24111831 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/WeatherMap.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:55b3fadc7c8d2a7ba2464670bd75374dbe5aa5de4811b25a385d598262bee1b2 3 | size 5303113 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/lightning_mask.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:6df9663e274d96a4e62089b977a118639045c2239829588e6fae946a0e7a5598 3 | size 22452 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/lightning_warp.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:4ebb22e9befb4cff4887b8a2529894dc72284b70cd2abfad323a78f2f73f3120 3 | size 150246 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/medieval_tower.mtl: -------------------------------------------------------------------------------- 1 | # Blender MTL File: 'medieval_tower.blend' 2 | # Material Count: 1 3 | 4 | newmtl TowerMaterial 5 | map_Kd T_Tower.png 6 | map_Pr R_Tower.png 7 | map_Pm M_Tower.png 8 | norm N_Tower.png 9 | Ns 323.999994 10 | Ka 0.202643 0.202643 0.202643 11 | Kd 0.800000 0.800000 0.800000 12 | Ks 0.500000 0.500000 0.500000 13 | Ke 0.000000 0.000000 0.000000 14 | Ni 1.000000 15 | d 1.000000 16 | illum 3 17 | -------------------------------------------------------------------------------- /resources/render_challenge_1/medieval_tower.obj: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:45429fd9584d6b875a5440396dac6751f88b23d34c5933b65a8c246331309baf 3 | size 202932 4 | -------------------------------------------------------------------------------- /resources/render_challenge_1/spaceship.mtl: -------------------------------------------------------------------------------- 1 | # Blender MTL File: 'spaceship.blend' 2 | # Material Count: 3 3 | 4 | newmtl Body 5 | Ns 575.999996 6 | Ka 0.200000 0.200000 0.200000 7 | Kd 0.029557 0.045186 0.102242 8 | Ks 0.500000 0.500000 0.500000 9 | Ke 0.000000 0.000000 0.000000 10 | Tf 1.00 1.00 1.00 11 | Ni 1.000000 12 | d 1.000000 13 | illum 3 14 | 15 | newmtl None 16 | Ns 500 17 | Ka 0.8 0.8 0.8 18 | Kd 0.8 0.8 0.8 19 | Ks 0.8 0.8 0.8 20 | Tf 1.00 1.00 1.00 21 | d 1 22 | illum 2 23 | 24 | newmtl PortEmissive 25 | Ns 900.000000 26 | Ka 1.000000 1.000000 1.000000 27 | Kd 1.000000 0.070360 0.026241 28 | Ks 0.500000 0.500000 0.500000 29 | Ke 2.500000 1.700000 0.700000 30 | Tf 1.00 1.00 1.00 31 | Ni 1.000000 32 | d 1.000000 33 | illum 2 34 | -------------------------------------------------------------------------------- /resources/render_challenge_1/spaceship.obj: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:ecac0668c102ede64122f93e873c872e91351cc8e15f30c96844415b2de2bace 3 | size 71772 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/catch_effect_0.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:a87ebace39a8b2edd13698feeb800779d0ea9db6aae43ee29fd3dc6c5b76e258 3 | size 7459 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/catch_effect_1.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:0d11171cce01a5a361d0627f8865e669498cd612f94a1c7d624d6de948038959 3 | size 7290 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/catch_effect_2.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:a13e917054fe9698f0c885c0e4d5149cb601e97d746cb9ba5db9063461ea7cb5 3 | size 6059 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/catch_effect_3.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:f5213aaa6f50ab9d92bf860cd59709ad676202aacf3d0f39b3f7802501055ae0 3 | size 2858 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/catch_effect_4.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:802cd7158e6d394518d71dd9dafb84a9d8f94159eaec149bffa0075ef39d9190 3 | size 1420 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/music_database.txt: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:91a73e0486c02eeeab07f53168d77460858cdae2b6583160c1c9189e372a6fc5 3 | size 264 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/note_blue.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:c81cbfcfb3ef57cef485f05fff69fbbb1a97d8517aa23991e82e703468e4712f 3 | size 3193 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/note_yellow.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:0f03ebd994107efe957520205ad9a88252cb1bb38720c7e80c1f681f8417e349 3 | size 2698 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/press_effect.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:35039489c3987ecfa4dc18f8c38241bd25fe520e6dbd10aeef224e6efe075f5c 3 | size 2214 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/record_imperial_march.txt: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:7e9f9991dc0a28e61b40f2c3d03b81fb344b74d44f1c9dfe53b3fba5a59c9670 3 | size 4587 4 | -------------------------------------------------------------------------------- /resources/rhythm_game/record_star_wars.txt: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:d3a3f253a9f716b68e1b5a415514d053f9a753e29c866bfd5de4f14d842f0dcb 3 | size 4782 4 | -------------------------------------------------------------------------------- /resources/skybox/HDRI/Ridgecrest_Road_4k_Bg.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:15745631f05053c4cfbd93ae41f5077170539027247425041c64430c340eb178 3 | size 5924883 4 | -------------------------------------------------------------------------------- /resources/skybox/HDRI/Ridgecrest_Road_Env.hdr: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:0e85bcdbd4e9a070dc3942bde5141ae148c30e798e675dfd83080c4f0280da3e 3 | size 120834 4 | -------------------------------------------------------------------------------- /resources/skybox/HDRI/Ridgecrest_Road_Ref.hdr: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:a09af4b3853cda3ec764321e42ec731bab0876b36e4b6603ad2534359885fa86 3 | size 6594471 4 | -------------------------------------------------------------------------------- /resources/skybox/HDRI/Ridgecrest_Road_Thumb.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:9a07f5cceb4d6fa0cfb23a7cec99e33f993b382a14231aa978fef161792f5f9c 3 | size 32420 4 | -------------------------------------------------------------------------------- /resources/skybox/HDRI/Ridgecrest_Road_preview.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:56943ddfec8cfba889269504dc7a84a9a8809b6ca8395f96b753e1929bb6c42f 3 | size 132107 4 | -------------------------------------------------------------------------------- /resources/skybox/ansel/dishonored.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:461b1ed48b3b1dbc671d82d72e65f8e5f1d7db65ccf7510ef093328235996c5f 3 | size 3748513 4 | -------------------------------------------------------------------------------- /resources/skybox/ansel/the_surge.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:2d7e213f11b750f8a5540e2737ed4aeab7384f4f7cf5210126b1327fce9524a8 3 | size 4637402 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/neg_x.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:3a663d8eaaed40cb5f52ff67e4a72d9e0fbe531fec85f1d545510be00ab7bf60 3 | size 629594 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/neg_y.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:02e86f0b20965358ac415e669aa3e0a2df18857a70596209cc72aacab5480409 3 | size 803330 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/neg_z.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:bceb1e27c85076bbf181fc9d7bf8f9e6ef5c747cb745626f1576d71c87b2911e 3 | size 603621 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/pos_x.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:61d0ec97121701fe907b0484e18d4278283f410b51b94c7c3269157fa40f25e0 3 | size 543591 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/pos_y.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:65ce5d468863420fb94f86685af161d4b1f9ecaff4b5240551ffe9df506dae58 3 | size 180961 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/pos_z.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:d2fe2d75e1aff8e91c6482e037897d57a1ad1415840ebcfc3425a45eebc7b055 3 | size 529762 4 | -------------------------------------------------------------------------------- /resources/skybox/cubemap1/readme.txt: -------------------------------------------------------------------------------- 1 | Author 2 | ====== 3 | 4 | This is the work of Emil Persson, aka Humus. 5 | http://www.humus.name 6 | 7 | 8 | 9 | License 10 | ======= 11 | 12 | This work is licensed under a Creative Commons Attribution 3.0 Unported License. 13 | http://creativecommons.org/licenses/by/3.0/ 14 | -------------------------------------------------------------------------------- /resources/skybox/placeholder/cubemap_back.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:474acc604680049f0d2c4b9da665ffcb1ada2948899cfdbc92a5e64875cfa7a2 3 | size 6276 4 | -------------------------------------------------------------------------------- /resources/skybox/placeholder/cubemap_bottom.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:8d94da2cae2ac4a89b9f5a0f7842bcfa302f7b3e798e8445a1e84cd3aeed3f02 3 | size 6329 4 | -------------------------------------------------------------------------------- /resources/skybox/placeholder/cubemap_front.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:82df3a8922087df5e5fa10c7757ac6a90cdd4654bcc2c4a1c9658fdf9178030b 3 | size 5262 4 | -------------------------------------------------------------------------------- /resources/skybox/placeholder/cubemap_left.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:00465242e1f4e165d04f212de4aa8b09d9c22e6991231fc045e6fe8081606ca6 3 | size 5663 4 | -------------------------------------------------------------------------------- /resources/skybox/placeholder/cubemap_right.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:7ed81816c6b725e3456467462ebef9e5a1fbe03c7d91e32b6004573062179429 3 | size 6841 4 | -------------------------------------------------------------------------------- /resources/skybox/placeholder/cubemap_top.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:5008893faf8c163b82cab0d0cdde427398601561ef6d3082c8f37fe6d009b3d8 3 | size 6678 4 | -------------------------------------------------------------------------------- /resources/textures/154.JPG: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:d7d7de7d0af59a3d2db947e8289467cedf6411593e7223d8f90197c5ecbfe708 3 | size 275648 4 | -------------------------------------------------------------------------------- /resources/textures/154_norm.JPG: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:0f5ad6fb9f19e418f3dc30c8333a14f6b4bb71c2cc2f822dd920a2d7d59a46fe 3 | size 460644 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/About these PBR files.txt: -------------------------------------------------------------------------------- 1 | These texture files were created by FreePBR.com and may be used freely in your video games and 3d work at no cost. They may not however be redistributed on other websites or anywhere else other than FreePBR.com. We think that is more than fair. :) We also would greatly appreciate it if some sorrt of credit was given if you do indeed use these textures in a published game. Other than that, keep on creating and have fun. :) -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-albedo.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:8e58f828222ad9d72cb7db912a15fac320810e76b3ce86044c7a1a0f8975d6dd 3 | size 8343672 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-ao.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:dfbaceedb662ecd7ea7c6b843aa5847044036ff16ad138cbc5320380f7cbb88a 3 | size 2474236 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-height.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:97d93aea0c6c1368ba590dfb574813600d6a3177c1dec737e58b278e84a154c0 3 | size 1583197 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-metalness.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:16ab4394f49880fe64b2a6405592a0325367f184d4829d8219612aef91c05f18 3 | size 15009 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-normal-ue.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:4deae498e0e368f24d8ed680ccc2a8877e4f13729612679d5f7fae8b0262cc69 3 | size 9905402 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-preview2.jpg: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:797405413d604419973ef340eea44efea7e393d78a4b1f7dc65fc95ef688cbde 3 | size 188640 4 | -------------------------------------------------------------------------------- /resources/textures/pbr_sandstone/sandstonecliff-roughness.png: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:83a74cf1b86a30ad8a704563601273d61881ce532feb09ec11dcfc1c21cb69ae 3 | size 2539681 4 | -------------------------------------------------------------------------------- /shaders/copy_texture.fs.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #include "deferred_common.glsl" 4 | 5 | //?#define COPY_MODE 6 | #define COPY_MODE_COLOR 0 7 | #define COPY_MODE_LIGHTPROBEDEPTH 1 8 | 9 | #if COPY_MODE == COPY_MODE_COLOR 10 | #define OUT_TYPE vec4 11 | #elif COPY_MODE == COPY_MODE_LIGHTPROBEDEPTH 12 | #define OUT_TYPE float 13 | #endif 14 | 15 | layout (binding = 0) uniform sampler2D sourceTexture; 16 | layout (location = 0) out OUT_TYPE outValue; 17 | 18 | in VS_OUT { 19 | vec2 screenUV; 20 | } fs_in; 21 | 22 | void main() { 23 | #if COPY_MODE == COPY_MODE_COLOR 24 | outValue = texture(sourceTexture, fs_in.screenUV); 25 | #elif COPY_MODE == COPY_MODE_LIGHTPROBEDEPTH 26 | float deviceZ = texture(sourceTexture, fs_in.screenUV).r; 27 | float lightProbeDepth = -getViewPositionFromSceneDepth(fs_in.screenUV, deviceZ).z; 28 | outValue = min(65000.0, lightProbeDepth); 29 | #endif 30 | } 31 | -------------------------------------------------------------------------------- /shaders/core/image_based_lighting.glsl: -------------------------------------------------------------------------------- 1 | //? #version 460 core 2 | // image_based_lighting.glsl 3 | 4 | // #todo-light-probe: SH encoding for indirect diffuse 5 | 6 | // Should match with image_based_lighting.h 7 | struct IrradianceVolume { 8 | vec3 minBounds; 9 | uint firstTileID; 10 | vec3 maxBounds; 11 | uint numProbes; 12 | uvec3 gridSize; 13 | float captureRadius; 14 | }; 15 | 16 | // Should match with image_based_lighting.h 17 | struct ReflectionProbe { 18 | vec3 positionWS; 19 | float captureRadius; 20 | uint cubemapIndex; 21 | uint _pad0; 22 | uint _pad1; 23 | uint _pad2; 24 | }; 25 | -------------------------------------------------------------------------------- /shaders/core/indirect_draw.glsl: -------------------------------------------------------------------------------- 1 | //? #version 460 core 2 | // indirect_draw.glsl 3 | 4 | // SSBO containing this struct should have std430 layout as it's not 16-byte aligned. 5 | struct DrawElementsIndirectCommand { 6 | uint count; 7 | uint instanceCount; 8 | uint firstIndex; 9 | int baseVertex; 10 | uint baseInstance; 11 | }; 12 | -------------------------------------------------------------------------------- /shaders/fullscreen_quad.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | // Intended to be used with DeferredRenderer::fullscreenQuad 4 | 5 | layout (location = 0) in vec3 position; 6 | 7 | out VS_OUT { 8 | vec2 screenUV; 9 | } vs_out; 10 | 11 | void main() { 12 | const vec3[4] vertices = vec3[4](vec3(-1,-1,1), vec3(1,-1,1), vec3(-1,1,1), vec3(1,1,1)); 13 | const vec2[4] texcoords = vec2[4](vec2(0,0), vec2(1,0), vec2(0,1), vec2(1,1)); 14 | 15 | vs_out.screenUV = texcoords[gl_VertexID]; 16 | 17 | gl_Position = vec4(vertices[gl_VertexID], 1); 18 | #if FORCE_Z_TO_ZERO 19 | gl_Position.z = 0.0; 20 | #endif 21 | } 22 | -------------------------------------------------------------------------------- /shaders/gi/octahedral_depth_atlas.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #include "../core/common.glsl" 4 | 5 | // -------------------------------------------------------- 6 | // Layout 7 | 8 | layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in; 9 | 10 | layout (location = 1) uniform uvec4 tileCoordAndSize; 11 | 12 | layout (binding = 0) uniform samplerCube inDepthCubemap; 13 | layout (binding = 0, r16f) uniform writeonly image2D outDepthAtlas; 14 | 15 | void main() { 16 | if (gl_GlobalInvocationID.x < tileCoordAndSize.z && gl_GlobalInvocationID.y < tileCoordAndSize.w) { 17 | float u = (float(gl_GlobalInvocationID.x) + 0.5) / float(tileCoordAndSize.z); 18 | float v = (float(gl_GlobalInvocationID.y) + 0.5) / float(tileCoordAndSize.w); 19 | vec2 uv = vec2(u, v); 20 | 21 | vec3 dir = ONVDecode(uv); 22 | float linearDepth = texture(inDepthCubemap, dir).x; 23 | 24 | ivec2 coord = ivec2(tileCoordAndSize.xy + gl_GlobalInvocationID.xy); 25 | imageStore(outDepthAtlas, coord, vec4(linearDepth, 0, 0, 0)); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /shaders/godray/god_ray_post.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #include "core/common.glsl" 4 | 5 | // -------------------------------------------------------- 6 | // Input 7 | 8 | in VS_OUT { 9 | vec2 screenUV; 10 | } interpolants; 11 | 12 | layout (binding = 0) uniform sampler2D godRay; 13 | 14 | // -------------------------------------------------------- 15 | // Output 16 | 17 | layout (location = 0) out vec4 outSceneColor; 18 | 19 | // -------------------------------------------------------- 20 | // Shader 21 | 22 | void main() { 23 | vec2 uv = interpolants.screenUV; 24 | 25 | outSceneColor = textureLod(godRay, uv, 0); 26 | } 27 | -------------------------------------------------------------------------------- /shaders/godray/god_ray_silhouette.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #include "deferred_common.glsl" 4 | 5 | layout (std140, binding = 1) uniform UBO_Silhouette { 6 | mat4 modelTransform; 7 | vec3 color; 8 | } ubo; 9 | 10 | ///////////////////////////////////////////////////////////////////////////////// 11 | 12 | #if VERTEX_SHADER 13 | 14 | layout (location = 0) in vec3 inPosition; 15 | 16 | void main() { 17 | mat4 model = ubo.modelTransform; 18 | mat4 viewProj = uboPerFrame.viewProjTransform; 19 | 20 | vec4 positionWS = model * vec4(inPosition, 1.0); 21 | 22 | vec4 positionCS = viewProj * positionWS; 23 | positionCS.xy += uboPerFrame.temporalJitter.xy * positionCS.w; 24 | 25 | gl_Position = positionCS; 26 | } 27 | 28 | #endif 29 | 30 | ///////////////////////////////////////////////////////////////////////////////// 31 | 32 | #if FRAGMENT_SHADER 33 | 34 | layout (location = 0) out vec4 outColor; 35 | 36 | void main() { 37 | outColor = vec4(ubo.color, 1.0); 38 | } 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /shaders/materials/indirect_draw_dummy.glsl: -------------------------------------------------------------------------------- 1 | // Dummy material for drawcall merging via indirect draw. 2 | // See depth_prepass.cpp. 3 | 4 | #define SHADINGMODEL MATERIAL_SHADINGMODEL_UNLIT 5 | #define USE_INDIRECT_DRAW 6 | #define TRANSFER_DRAW_ID 7 | 8 | VPO_BEGIN 9 | vec3 getVertexPositionOffset(VertexShaderInput vsi) { 10 | return vec3(0.0); 11 | } 12 | VPO_END 13 | 14 | ATTR_BEGIN 15 | MaterialAttributes getMaterialAttributes() { 16 | MaterialAttributes_Unlit attr; 17 | 18 | attr.color = vec3(0.9, 0.9, 0.9); 19 | 20 | return attr; 21 | } 22 | ATTR_END 23 | -------------------------------------------------------------------------------- /shaders/materials/solid_color.glsl: -------------------------------------------------------------------------------- 1 | // Simple DefaultLit material that uses constant values for each material attribute. 2 | 3 | #define SHADINGMODEL MATERIAL_SHADINGMODEL_DEFAULTLIT 4 | 5 | PARAMETER_CONSTANT(vec3, albedo) 6 | PARAMETER_CONSTANT(float, metallic) 7 | PARAMETER_CONSTANT(float, roughness) 8 | PARAMETER_CONSTANT(vec3, emissive) 9 | 10 | VPO_BEGIN 11 | vec3 getVertexPositionOffset(VertexShaderInput vsi) { 12 | return vec3(0.0); 13 | } 14 | VPO_END 15 | 16 | ATTR_BEGIN 17 | MaterialAttributes getMaterialAttributes() { 18 | MaterialAttributes_DefaultLit attr; 19 | 20 | attr.albedo = uboMaterial.albedo; 21 | attr.normal = vec3(0.0, 0.0, 1.0); 22 | attr.metallic = uboMaterial.metallic; 23 | attr.roughness = uboMaterial.roughness; 24 | attr.emissive = uboMaterial.emissive; 25 | attr.localAO = 1.0; 26 | 27 | return attr; 28 | } 29 | ATTR_END 30 | -------------------------------------------------------------------------------- /shaders/materials/texture_viewer.glsl: -------------------------------------------------------------------------------- 1 | // Unlit material that displays a source texture. 2 | // NOTE: Wow. "unlit_text" and "unlit_texture_viewer" have a same hash. 3 | 4 | #define SHADINGMODEL MATERIAL_SHADINGMODEL_UNLIT 5 | 6 | PARAMETER_TEXTURE(0, sampler2D, inputTexture) 7 | 8 | VPO_BEGIN 9 | vec3 getVertexPositionOffset(VertexShaderInput vsi) { 10 | return vec3(0.0); 11 | } 12 | VPO_END 13 | 14 | ATTR_BEGIN 15 | MaterialAttributes getMaterialAttributes() { 16 | MaterialAttributes_Unlit attr; 17 | 18 | attr.color = texture(inputTexture, interpolants.texcoord).rgb; 19 | 20 | return attr; 21 | } 22 | ATTR_END 23 | -------------------------------------------------------------------------------- /shaders/materials/unlit.glsl: -------------------------------------------------------------------------------- 1 | // Simple Unlit material that outputs a constant color. 2 | 3 | #define SHADINGMODEL MATERIAL_SHADINGMODEL_UNLIT 4 | 5 | PARAMETER_CONSTANT(vec3, color) 6 | 7 | VPO_BEGIN 8 | vec3 getVertexPositionOffset(VertexShaderInput vsi) { 9 | return vec3(0.0); 10 | } 11 | VPO_END 12 | 13 | ATTR_BEGIN 14 | MaterialAttributes getMaterialAttributes() { 15 | MaterialAttributes_Unlit attr; 16 | 17 | attr.color = uboMaterial.color; 18 | 19 | return attr; 20 | } 21 | ATTR_END 22 | -------------------------------------------------------------------------------- /shaders/omni_shadow_map.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout (std140, binding = 1) uniform UBO_OmniShadow { 4 | mat4 model; 5 | mat4 viewproj; 6 | vec4 lightPositionAndZFar; 7 | } ubo; 8 | 9 | #if VERTEX_SHADER 10 | 11 | layout (location = 0) in vec3 position; 12 | 13 | out VS_OUT { 14 | vec3 wPos; 15 | } vs_out; 16 | 17 | void main() { 18 | vec4 wPos = ubo.model * vec4(position, 1.0); 19 | vs_out.wPos = wPos.xyz; 20 | 21 | gl_Position = ubo.viewproj * wPos; 22 | } 23 | 24 | #endif 25 | 26 | //////////////////////////////////////////////////////////// 27 | 28 | #if FRAGMENT_SHADER 29 | 30 | in VS_OUT { 31 | vec3 wPos; 32 | } fs_in; 33 | 34 | void main() { 35 | float dist = length(fs_in.wPos - ubo.lightPositionAndZFar.xyz); 36 | dist = dist / ubo.lightPositionAndZFar.w; 37 | 38 | gl_FragDepth = dist; 39 | } 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /shaders/overlay/overlay_image.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #if VERTEX_SHADER 4 | #define Interpolants out 5 | #elif FRAGMENT_SHADER 6 | #define Interpolants in 7 | #endif 8 | 9 | Interpolants OverlayImageInterpolants { 10 | vec2 uv; 11 | } interpolants; 12 | 13 | layout (std140, binding = 1) uniform UBO_OverlayImage { 14 | mat4 transform; 15 | } ubo; 16 | 17 | ////////////////////////////////////////////////////////////////////////// 18 | 19 | #if VERTEX_SHADER 20 | 21 | layout (location = 0) in vec3 position; 22 | layout (location = 1) in vec2 uv; 23 | 24 | void main() { 25 | interpolants.uv = uv; 26 | gl_Position = ubo.transform * vec4(position, 1.0f); 27 | } 28 | 29 | #endif // VERTEX_SHADER 30 | 31 | ////////////////////////////////////////////////////////////////////////// 32 | 33 | #if FRAGMENT_SHADER 34 | 35 | layout (binding = 0) uniform sampler2D imageTexture; 36 | 37 | out vec4 outColor; 38 | 39 | void main() { 40 | outColor = texture(imageTexture, interpolants.uv); 41 | } 42 | 43 | #endif // FRAGMENT_SHADER 44 | -------------------------------------------------------------------------------- /shaders/overlay/overlay_standard.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #if VERTEX_SHADER 4 | #define Interpolants out 5 | #elif FRAGMENT_SHADER 6 | #define Interpolants in 7 | #endif 8 | 9 | Interpolants OverlayStandardInterpolants { 10 | vec2 uv; 11 | } interpolants; 12 | 13 | layout (std140, binding = 1) uniform UBO_OverlayStandard { 14 | mat4 transform; 15 | vec4 color; 16 | } ubo; 17 | 18 | ////////////////////////////////////////////////////////////////////////// 19 | 20 | #if VERTEX_SHADER 21 | 22 | layout (location = 0) in vec3 position; 23 | layout (location = 1) in vec2 uv; 24 | 25 | void main() { 26 | interpolants.uv = uv; 27 | gl_Position = ubo.transform * vec4(position, 1.0f); 28 | } 29 | 30 | #endif // VERTEX_SHADER 31 | 32 | ////////////////////////////////////////////////////////////////////////// 33 | 34 | #if FRAGMENT_SHADER 35 | 36 | out vec4 out_color; 37 | 38 | void main() { 39 | // #todo: texture sampling 40 | out_color = ubo.color; 41 | } 42 | 43 | #endif // FRAGMENT_SHADER 44 | -------------------------------------------------------------------------------- /shaders/postprocess/auto_exposure_scene_avg.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #include "core/common.glsl" 4 | 5 | // -------------------------------------------------------- 6 | // Input 7 | 8 | in VS_OUT { 9 | vec2 screenUV; 10 | } fs_in; 11 | 12 | layout (location = 1) uniform float minLogLuminance; 13 | 14 | layout (binding = 0) uniform sampler2D sceneColor; 15 | 16 | // -------------------------------------------------------- 17 | // Output 18 | 19 | layout (location = 0) out float outLogLuminance; 20 | 21 | // -------------------------------------------------------- 22 | // Shader 23 | 24 | void main() { 25 | vec2 uv = fs_in.screenUV; 26 | 27 | vec3 rgb = textureLod(sceneColor, uv, 0).rgb; 28 | float sceneLuminance = dot(rgb, vec3(0.2125, 0.7154, 0.0721)); 29 | 30 | outLogLuminance = max(minLogLuminance, log(sceneLuminance)); 31 | } 32 | -------------------------------------------------------------------------------- /shaders/sky/blit_cubemap.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout (location = 0) uniform mat4 transform; 4 | layout (location = 1) uniform float inputMip; 5 | 6 | layout (binding = 0) uniform samplerCube sourceCube; 7 | 8 | // ------------------------------------------------------ 9 | 10 | #if VERTEX_SHADER 11 | 12 | layout (location = 0) in vec3 position; 13 | 14 | out vec3 localDir; 15 | 16 | void main() { 17 | //localDir = (transform * vec4(normalize(position), 0)).xyz; 18 | localDir = normalize(position); 19 | gl_Position = transform * vec4(position, 1.0); 20 | } 21 | 22 | #endif // VERTEX_SHADER 23 | 24 | // ------------------------------------------------------ 25 | 26 | #if FRAGMENT_SHADER 27 | 28 | in vec3 localDir; 29 | out vec4 outColor; 30 | 31 | void main() { 32 | outColor = textureLod(sourceCube, localDir, inputMip); 33 | } 34 | 35 | #endif // FRAGMENT_SHADER 36 | -------------------------------------------------------------------------------- /shaders/sky/copy_cubemap.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout (local_size_x = 8, local_size_y = 8, local_size_z = 6) in; 4 | 5 | layout (location = 1) uniform uint cubemapSize; 6 | 7 | layout (binding = 0, rgba16f) uniform readonly imageCube inputTexture; 8 | layout (binding = 1, rgba16f) uniform writeonly imageCube outputTexture; 9 | 10 | void main() { 11 | if (gl_GlobalInvocationID.x < cubemapSize && gl_GlobalInvocationID.y < cubemapSize) { 12 | ivec3 coord = ivec3(gl_GlobalInvocationID); 13 | vec4 color = imageLoad(inputTexture, coord); 14 | imageStore(outputTexture, coord, color); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /shaders/ssr_composite.glsl: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | // -------------------------------------------------------- 4 | // Input 5 | 6 | in VS_OUT { 7 | vec2 screenUV; 8 | } fs_in; 9 | 10 | layout (binding = 0) uniform sampler2D inSSR; 11 | 12 | // -------------------------------------------------------- 13 | // Output 14 | 15 | layout (location = 0) out vec4 outSceneColor; 16 | 17 | // -------------------------------------------------------- 18 | // Shader 19 | 20 | void main() { 21 | vec2 screenUV = fs_in.screenUV; 22 | vec3 ssr = texture(inSSR, screenUV).rgb; 23 | outSceneColor = vec4(ssr, 0.0); 24 | } 25 | -------------------------------------------------------------------------------- /thirdparty/CopyBinaries.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | setlocal 3 | 4 | set SolutionDir=%1 5 | set SolutionConfig=%2 6 | 7 | echo SolutionDir=%SolutionDir% 8 | echo Configuration=%SolutionConfig% 9 | 10 | if not exist "%SolutionDir%\PathosEngine.sln" ( 11 | echo First argument should be the solution directory, but couldn't find PathosEngine.sln 12 | exit 13 | ) 14 | 15 | set ValidConfig=0 16 | if "%SolutionConfig%" == "Debug" set ValidConfig=1 17 | if "%SolutionConfig%" == "Release" set ValidConfig=1 18 | if %ValidConfig%==0 ( 19 | echo Second argument should be Debug or Release 20 | exit 21 | ) 22 | 23 | if "%SolutionConfig%" == "Debug" set FreeGLUTFile=freeglutd.dll 24 | if "%SolutionConfig%" == "Release" set FreeGLUTFile=freeglut.dll 25 | 26 | xcopy /y /d "%SolutionDir%\thirdparty\freeglut\binary\%FreeGLUTFile%" "%SolutionDir%\bin\%SolutionConfig%\" 27 | xcopy /y /d "%SolutionDir%\thirdparty\freeimage-3.18.0\binary\freeimage.dll" "%SolutionDir%\bin\%SolutionConfig%\" 28 | xcopy /y /d "%SolutionDir%\thirdparty\bass\build\x64\bass.dll" "%SolutionDir%\bin\%SolutionConfig%\" 29 | 30 | endlocal 31 | -------------------------------------------------------------------------------- /thirdparty/ThirdParty.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | -------------------------------------------------------------------------------- /thirdparty/assimp/binary/assimp-vc140-mt.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/assimp/binary/assimp-vc140-mt.dll -------------------------------------------------------------------------------- /thirdparty/assimp/binary/assimp-vc140-mt.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/assimp/binary/assimp-vc140-mt.lib -------------------------------------------------------------------------------- /thirdparty/assimp/source/assimp/.editorconfig: -------------------------------------------------------------------------------- 1 | # See for details 2 | 3 | [*.{h,hpp,inl}] 4 | end_of_line = lf 5 | insert_final_newline = true 6 | trim_trailing_whitespace = true 7 | indent_size = 4 8 | indent_style = space 9 | -------------------------------------------------------------------------------- /thirdparty/assimp/source/assimp/Compiler/poppack1.h: -------------------------------------------------------------------------------- 1 | 2 | // =============================================================================== 3 | // May be included multiple times - resets structure packing to the defaults 4 | // for all supported compilers. Reverts the changes made by #include 5 | // 6 | // Currently this works on the following compilers: 7 | // MSVC 7,8,9 8 | // GCC 9 | // BORLAND (complains about 'pack state changed but not reverted', but works) 10 | // =============================================================================== 11 | 12 | #ifndef AI_PUSHPACK_IS_DEFINED 13 | # error pushpack1.h must be included after poppack1.h 14 | #endif 15 | 16 | // reset packing to the original value 17 | #if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) 18 | # pragma pack( pop ) 19 | #endif 20 | #undef PACK_STRUCT 21 | 22 | #undef AI_PUSHPACK_IS_DEFINED 23 | -------------------------------------------------------------------------------- /thirdparty/bass/bass24.zip: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:5b2ec936d4496d2d143e2c42a0c1cba90d89bcc71be1ad4d97cd49b81345f319 3 | size 921851 4 | -------------------------------------------------------------------------------- /thirdparty/freeglut/binary/freeglut.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/freeglut/binary/freeglut.dll -------------------------------------------------------------------------------- /thirdparty/freeglut/binary/freeglut.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/freeglut/binary/freeglut.lib -------------------------------------------------------------------------------- /thirdparty/freeglut/binary/freeglutd.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/freeglut/binary/freeglutd.dll -------------------------------------------------------------------------------- /thirdparty/freeglut/binary/freeglutd.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/freeglut/binary/freeglutd.lib -------------------------------------------------------------------------------- /thirdparty/freeglut/source/GL/freeglut.h: -------------------------------------------------------------------------------- 1 | #ifndef __FREEGLUT_H__ 2 | #define __FREEGLUT_H__ 3 | 4 | /* 5 | * freeglut.h 6 | * 7 | * The freeglut library include file 8 | * 9 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 10 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 11 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 12 | * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 13 | * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 14 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 15 | */ 16 | 17 | #include "freeglut_std.h" 18 | #include "freeglut_ext.h" 19 | 20 | /*** END OF FILE ***/ 21 | 22 | #endif /* __FREEGLUT_H__ */ 23 | -------------------------------------------------------------------------------- /thirdparty/freeglut/source/GL/glut.h: -------------------------------------------------------------------------------- 1 | #ifndef __GLUT_H__ 2 | #define __GLUT_H__ 3 | 4 | /* 5 | * glut.h 6 | * 7 | * The freeglut library include file 8 | * 9 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 10 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 11 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 12 | * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 13 | * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 14 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 15 | */ 16 | 17 | #include "freeglut_std.h" 18 | 19 | /*** END OF FILE ***/ 20 | 21 | #endif /* __GLUT_H__ */ 22 | -------------------------------------------------------------------------------- /thirdparty/freeimage-3.18.0/binary/FreeImage.dll: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:94b7e1c9f1de4e29b96e4105abdf1f6e7da960a1ec275d74630e0e710a423a18 3 | size 6906368 4 | -------------------------------------------------------------------------------- /thirdparty/freeimage-3.18.0/binary/FreeImage.lib: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:9c61e225bcf576522986277b25e4b279d2fb18f4f5a773f3e7208a82b5f61620 3 | size 65322 4 | -------------------------------------------------------------------------------- /thirdparty/freetype-2.9.1/binary/freetype.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/freetype-2.9.1/binary/freetype.lib -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:629366c6c8ac52f172327cb42a5811ce38462647590536ae660a66d9043720ea 3 | size 2668 4 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //! Workaround for compatibility with other libraries 4 | #ifdef max 5 | #undef max 6 | #endif 7 | 8 | //! Workaround for compatibility with other libraries 9 | #ifdef min 10 | #undef min 11 | #endif 12 | 13 | //! Workaround for Android 14 | #ifdef isnan 15 | #undef isnan 16 | #endif 17 | 18 | //! Workaround for Android 19 | #ifdef isinf 20 | #undef isinf 21 | #endif 22 | 23 | //! Workaround for Chrone Native Client 24 | #ifdef log2 25 | #undef log2 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/compute_vector_relational.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "compute_common.hpp" 4 | #include "setup.hpp" 5 | #include 6 | 7 | namespace glm{ 8 | namespace detail 9 | { 10 | template 11 | struct compute_equal 12 | { 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 14 | { 15 | return a == b; 16 | } 17 | }; 18 | /* 19 | template 20 | struct compute_equal 21 | { 22 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 23 | { 24 | return detail::compute_abs::is_signed>::call(b - a) <= static_cast(0); 25 | //return std::memcmp(&a, &b, sizeof(T)) == 0; 26 | } 27 | }; 28 | */ 29 | }//namespace detail 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/func_exponential_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_exponential_simd.inl 3 | 4 | #include "../simd/exponential.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_sqrt<4, float, Q, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) 15 | { 16 | vec<4, float, Q> Result; 17 | Result.data = _mm_sqrt_ps(v.data); 18 | return Result; 19 | } 20 | }; 21 | 22 | # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE 23 | template<> 24 | struct compute_sqrt<4, float, aligned_lowp, true> 25 | { 26 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) 27 | { 28 | vec<4, float, aligned_lowp> Result; 29 | Result.data = glm_vec4_sqrt_lowp(v.data); 30 | return Result; 31 | } 32 | }; 33 | # endif 34 | }//namespace detail 35 | }//namespace glm 36 | 37 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 38 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/glm/source/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | 5 | namespace glm{ 6 | namespace detail 7 | { 8 | typedef short hdata; 9 | 10 | GLM_FUNC_DECL float toFloat32(hdata value); 11 | GLM_FUNC_DECL hdata toFloat16(float const& value); 12 | 13 | }//namespace detail 14 | }//namespace glm 15 | 16 | #include "type_half.inl" 17 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_common.inl: -------------------------------------------------------------------------------- 1 | #include "../matrix.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) 7 | { 8 | return mat(x) * (static_cast(1) - a) + mat(y) * a; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) 13 | { 14 | return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, double, defaultp> dmat2x2; 16 | 17 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, double, defaultp> dmat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, double, defaultp> dmat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, double, defaultp> dmat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, double, defaultp> dmat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, double, defaultp> dmat3x3; 16 | 17 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, double, defaultp> dmat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, double, defaultp> dmat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, double, defaultp> dmat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, double, defaultp> dmat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_double4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, double, defaultp> dmat4x4; 16 | 17 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, double, defaultp> dmat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, float, defaultp> mat2x2; 16 | 17 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, float, defaultp> mat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, float, defaultp> mat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, float, defaultp> mat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, float, defaultp> mat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, float, defaultp> mat3x3; 16 | 17 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, float, defaultp> mat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, float, defaultp> mat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, float, defaultp> mat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, float, defaultp> mat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_float4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @ingroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, float, defaultp> mat4x4; 16 | 17 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, float, defaultp> mat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x2 2 | /// @file glm/ext/matrix_int2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x2 GLM_EXT_matrix_int2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x2 25 | /// @{ 26 | 27 | /// Signed integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_int2x2 30 | typedef mat<2, 2, int, defaultp> imat2x2; 31 | 32 | /// Signed integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_int2x2 35 | typedef mat<2, 2, int, defaultp> imat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3 2 | /// @file glm/ext/matrix_int2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_int2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x3 25 | /// @{ 26 | 27 | /// Signed integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_int2x3 30 | typedef mat<2, 3, int, defaultp> imat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4 2 | /// @file glm/ext/matrix_int2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x4 25 | /// @{ 26 | 27 | /// Signed integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_int2x4 30 | typedef mat<2, 4, int, defaultp> imat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2 2 | /// @file glm/ext/matrix_int3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_int3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x2 25 | /// @{ 26 | 27 | /// Signed integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_int3x2 30 | typedef mat<3, 2, int, defaultp> imat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x3 2 | /// @file glm/ext/matrix_int3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x3 GLM_EXT_matrix_int3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x3 25 | /// @{ 26 | 27 | /// Signed integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_int3x3 30 | typedef mat<3, 3, int, defaultp> imat3x3; 31 | 32 | /// Signed integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_int3x3 35 | typedef mat<3, 3, int, defaultp> imat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4 2 | /// @file glm/ext/matrix_int3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4 GLM_EXT_matrix_int3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_int3x4 30 | typedef mat<3, 4, int, defaultp> imat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2 2 | /// @file glm/ext/matrix_int4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2 GLM_EXT_matrix_int4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x2 25 | /// @{ 26 | 27 | /// Signed integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_int4x2 30 | typedef mat<4, 2, int, defaultp> imat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3 2 | /// @file glm/ext/matrix_int4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3 GLM_EXT_matrix_int4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x3 25 | /// @{ 26 | 27 | /// Signed integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_int4x3 30 | typedef mat<4, 3, int, defaultp> imat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_int4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x4 2 | /// @file glm/ext/matrix_int4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x4 GLM_EXT_matrix_int4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x4 25 | /// @{ 26 | 27 | /// Signed integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_int4x4 30 | typedef mat<4, 4, int, defaultp> imat4x4; 31 | 32 | /// Signed integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_int4x4 35 | typedef mat<4, 4, int, defaultp> imat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x2 2 | /// @file glm/ext/matrix_uint2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x2 GLM_EXT_matrix_uint2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x2 25 | /// @{ 26 | 27 | /// Unsigned integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x2 30 | typedef mat<2, 2, uint, defaultp> umat2x2; 31 | 32 | /// Unsigned integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_uint2x2 35 | typedef mat<2, 2, uint, defaultp> umat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3 2 | /// @file glm/ext/matrix_uint2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_uint2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x3 25 | /// @{ 26 | 27 | /// Unsigned integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x3 30 | typedef mat<2, 3, uint, defaultp> umat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4 2 | /// @file glm/ext/matrix_uint2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x4 25 | /// @{ 26 | 27 | /// Unsigned integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x4 30 | typedef mat<2, 4, uint, defaultp> umat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2 2 | /// @file glm/ext/matrix_uint3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_uint3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x2 25 | /// @{ 26 | 27 | /// Unsigned integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x2 30 | typedef mat<3, 2, uint, defaultp> umat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x3 2 | /// @file glm/ext/matrix_uint3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x3 GLM_EXT_matrix_uint3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x3 25 | /// @{ 26 | 27 | /// Unsigned integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x3 30 | typedef mat<3, 3, uint, defaultp> umat3x3; 31 | 32 | /// Unsigned integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_uint3x3 35 | typedef mat<3, 3, uint, defaultp> umat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4 2 | /// @file glm/ext/matrix_uint3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4 GLM_EXT_matrix_uint3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x4 30 | typedef mat<3, 4, uint, defaultp> umat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2 2 | /// @file glm/ext/matrix_uint4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2 GLM_EXT_matrix_uint4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x2 25 | /// @{ 26 | 27 | /// Unsigned integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x2 30 | typedef mat<4, 2, uint, defaultp> umat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3 2 | /// @file glm/ext/matrix_uint4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3 GLM_EXT_matrix_uint4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x3 25 | /// @{ 26 | 27 | /// Unsigned integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x3 30 | typedef mat<4, 3, uint, defaultp> umat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/matrix_uint4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x4 2 | /// @file glm/ext/matrix_uint4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x4 GLM_EXT_matrix_uint4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x4 25 | /// @{ 26 | 27 | /// Unsigned integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x4 30 | typedef mat<4, 4, uint, defaultp> umat4x4; 31 | 32 | /// Unsigned integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_uint4x4 35 | typedef mat<4, 4, uint, defaultp> umat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/quaternion_common_simd.inl: -------------------------------------------------------------------------------- 1 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_dot, float, true> 8 | { 9 | static GLM_FUNC_QUALIFIER float call(qua const& x, qua const& y) 10 | { 11 | return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); 12 | } 13 | }; 14 | }//namespace detail 15 | }//namespace glm 16 | 17 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 18 | 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/quaternion_transform.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& v) 5 | { 6 | vec<3, T, Q> Tmp = v; 7 | 8 | // Axis of rotation must be normalised 9 | T len = glm::length(Tmp); 10 | if(abs(len - static_cast(1)) > static_cast(0.001)) 11 | { 12 | T oneOverLen = static_cast(1) / len; 13 | Tmp.x *= oneOverLen; 14 | Tmp.y *= oneOverLen; 15 | Tmp.z *= oneOverLen; 16 | } 17 | 18 | T const AngleRad(angle); 19 | T const Sin = sin(AngleRad * static_cast(0.5)); 20 | 21 | return q * qua(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 22 | } 23 | }//namespace glm 24 | 25 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/scalar_constants.inl: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() 7 | { 8 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'epsilon' only accepts floating-point inputs"); 9 | return std::numeric_limits::epsilon(); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() 14 | { 15 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'pi' only accepts floating-point inputs"); 16 | return static_cast(3.14159265358979323846264338327950288); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType cos_one_over_two() 21 | { 22 | return genType(0.877582561890372716130286068203503191); 23 | } 24 | } //namespace glm 25 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/scalar_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_packing 2 | /// @file glm/ext/scalar_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_scalar_packing GLM_EXT_scalar_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert scalar values to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_scalar_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_scalar_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "scalar_packing.inl" 33 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/glm/source/glm/ext/scalar_packing.inl -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_bool1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1 2 | /// @file glm/ext/vector_bool1.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes bvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_bool1_precision extension. 12 | 13 | #pragma once 14 | 15 | #include "../detail/type_vec1.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_vector_bool1 extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_bool1 24 | /// @{ 25 | 26 | /// 1 components vector of boolean. 27 | typedef vec<1, bool, defaultp> bvec1; 28 | 29 | /// @} 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_bool1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1_precision 2 | /// @file glm/ext/vector_bool1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | #include "../detail/type_vec1.hpp" 14 | 15 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 16 | # pragma message("GLM: GLM_EXT_vector_bool1_precision extension included") 17 | #endif 18 | 19 | namespace glm 20 | { 21 | /// @addtogroup ext_vector_bool1_precision 22 | /// @{ 23 | 24 | /// 1 component vector of bool values. 25 | typedef vec<1, bool, highp> highp_bvec1; 26 | 27 | /// 1 component vector of bool values. 28 | typedef vec<1, bool, mediump> mediump_bvec1; 29 | 30 | /// 1 component vector of bool values. 31 | typedef vec<1, bool, lowp> lowp_bvec1; 32 | 33 | /// @} 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_bool2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, bool, defaultp> bvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_bool3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, bool, defaultp> bvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_bool4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, bool, defaultp> bvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_double1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_double1 2 | /// @file glm/ext/vector_double1.hpp 3 | /// 4 | /// @defgroup ext_vector_double1 GLM_EXT_vector_double1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_double1_precision extension. 12 | /// @see ext_vector_float1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_double1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_double1 25 | /// @{ 26 | 27 | /// 1 components vector of double-precision floating-point numbers. 28 | typedef vec<1, double, defaultp> dvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_double2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, double, defaultp> dvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_double3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, double, defaultp> dvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_double4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, double, defaultp> dvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_float1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_float1 2 | /// @file glm/ext/vector_float1.hpp 3 | /// 4 | /// @defgroup ext_vector_float1 GLM_EXT_vector_float1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_float1_precision extension. 12 | /// @see ext_vector_double1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_float1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_float1 25 | /// @{ 26 | 27 | /// 1 components vector of single-precision floating-point numbers. 28 | typedef vec<1, float, defaultp> vec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_float2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, float, defaultp> vec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_float3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, float, defaultp> vec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_float4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, float, defaultp> vec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_int1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1 2 | /// @file glm/ext/vector_int1.hpp 3 | /// 4 | /// @defgroup ext_vector_int1 GLM_EXT_vector_int1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes ivec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_uint1 extension. 12 | /// @see ext_vector_int1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_int1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_int1 25 | /// @{ 26 | 27 | /// 1 component vector of signed integer numbers. 28 | typedef vec<1, int, defaultp> ivec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_int2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, int, defaultp> ivec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_int3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, int, defaultp> ivec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_int4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, int, defaultp> ivec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_packing 2 | /// @file glm/ext/vector_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_vector_packing GLM_EXT_vector_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert vectors to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "vector_packing.inl" 33 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/glm/source/glm/ext/vector_packing.inl -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_uint1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1 2 | /// @file glm/ext/vector_uint1.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes uvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_int1 extension. 12 | /// @see ext_vector_uint1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_uint1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_uint1 25 | /// @{ 26 | 27 | /// 1 component vector of unsigned integer numbers. 28 | typedef vec<1, unsigned int, defaultp> uvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_uint2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, unsigned int, defaultp> uvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_uint3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, unsigned int, defaultp> uvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/ext/vector_uint4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, unsigned int, defaultp> uvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/glm/source/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtc/vec1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_vec1 GLM_GTC_vec1 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add vec1, ivec1, uvec1 and bvec1 types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../ext/vector_bool1.hpp" 17 | #include "../ext/vector_bool1_precision.hpp" 18 | #include "../ext/vector_float1.hpp" 19 | #include "../ext/vector_float1_precision.hpp" 20 | #include "../ext/vector_double1.hpp" 21 | #include "../ext/vector_double1_precision.hpp" 22 | #include "../ext/vector_int1.hpp" 23 | #include "../ext/vector_int1_sized.hpp" 24 | #include "../ext/vector_uint1.hpp" 25 | #include "../ext/vector_uint1_sized.hpp" 26 | 27 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTC_vec1 extension included") 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/exterior_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | 3 | #include 4 | 5 | namespace glm { 6 | namespace detail 7 | { 8 | template 9 | struct compute_cross_vec2 10 | { 11 | GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); 14 | 15 | return v.x * u.y - u.x * v.y; 16 | } 17 | }; 18 | }//namespace detail 19 | 20 | template 21 | GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 22 | { 23 | return detail::compute_cross_vec2::value>::call(x, y); 24 | } 25 | }//namespace glm 26 | 27 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | 3 | #include 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) 9 | { 10 | return vec(v) / static_cast(std::numeric_limits::max()); 11 | } 12 | 13 | }//namespace glm 14 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | 3 | #include "../exponential.hpp" 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER T gauss 9 | ( 10 | T x, 11 | T ExpectedValue, 12 | T StandardDeviation 13 | ) 14 | { 15 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER T gauss 20 | ( 21 | vec<2, T, Q> const& Coord, 22 | vec<2, T, Q> const& ExpectedValue, 23 | vec<2, T, Q> const& StandardDeviation 24 | ) 25 | { 26 | vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 27 | return exp(-(Squared.x + Squared.y)); 28 | } 29 | }//namespace glm 30 | 31 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER bool rightHanded 7 | ( 8 | vec<3, T, Q> const& tangent, 9 | vec<3, T, Q> const& binormal, 10 | vec<3, T, Q> const& normal 11 | ) 12 | { 13 | return dot(cross(normal, tangent), binormal) > T(0); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool leftHanded 18 | ( 19 | vec<3, T, Q> const& tangent, 20 | vec<3, T, Q> const& binormal, 21 | vec<3, T, Q> const& normal 22 | ) 23 | { 24 | return dot(cross(normal, tangent), binormal) < T(0); 25 | } 26 | }//namespace glm 27 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) 7 | { 8 | return glm::log(x) / glm::log(base); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) 13 | { 14 | return glm::log(x) / glm::log(base); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 7 | ( 8 | vec<3, T, Q> const& x 9 | ) 10 | { 11 | mat<3, 3, T, Q> Result(T(0)); 12 | Result[0][1] = x.z; 13 | Result[1][0] = -x.z; 14 | Result[0][2] = -x.y; 15 | Result[2][0] = x.y; 16 | Result[1][2] = x.x; 17 | Result[2][1] = -x.x; 18 | return Result; 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 23 | ( 24 | vec<3, T, Q> const& x 25 | ) 26 | { 27 | mat<4, 4, T, Q> Result(T(0)); 28 | Result[0][1] = x.z; 29 | Result[1][0] = -x.z; 30 | Result[0][2] = -x.y; 31 | Result[2][0] = x.y; 32 | Result[1][2] = x.x; 33 | Result[2][1] = -x.x; 34 | return Result; 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codeonwort/pathosengine/19d98cca377f3f594d625155dda6192881a5f0d3/thirdparty/glm/source/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T mixedProduct 7 | ( 8 | vec<3, T, Q> const& v1, 9 | vec<3, T, Q> const& v2, 10 | vec<3, T, Q> const& v3 11 | ) 12 | { 13 | return dot(cross(v1, v2), v3); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal 7 | ( 8 | vec<3, T, Q> const& p1, 9 | vec<3, T, Q> const& p2, 10 | vec<3, T, Q> const& p3 11 | ) 12 | { 13 | return normalize(cross(p1 - p2, p1 - p3)); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) 7 | { 8 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) 13 | { 14 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType pow2(genType const& x) 7 | { 8 | return x * x; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER genType pow3(genType const& x) 13 | { 14 | return x * x * x; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER genType pow4(genType const& x) 19 | { 20 | return (x * x) * (x * x); 21 | } 22 | }//namespace glm 23 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) 7 | { 8 | mat<3, 3, T, Q> r = m; 9 | 10 | r[0] = normalize(r[0]); 11 | 12 | T d0 = dot(r[0], r[1]); 13 | r[1] -= r[0] * d0; 14 | r[1] = normalize(r[1]); 15 | 16 | T d1 = dot(r[1], r[2]); 17 | d0 = dot(r[0], r[2]); 18 | r[2] -= r[0] * d0 + r[1] * d1; 19 | r[2] = normalize(r[2]); 20 | 21 | return r; 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) 26 | { 27 | return normalize(x - y * dot(y, x)); 28 | } 29 | }//namespace glm 30 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) 7 | { 8 | return x - proj(x, Normal); 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> polar 7 | ( 8 | vec<3, T, Q> const& euclidean 9 | ) 10 | { 11 | T const Length(length(euclidean)); 12 | vec<3, T, Q> const tmp(euclidean / Length); 13 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 14 | 15 | return vec<3, T, Q>( 16 | asin(tmp.y), // latitude 17 | atan(tmp.x, tmp.z), // longitude 18 | xz_dist); // xz distance 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean 23 | ( 24 | vec<2, T, Q> const& polar 25 | ) 26 | { 27 | T const latitude(polar.x); 28 | T const longitude(polar.y); 29 | 30 | return vec<3, T, Q>( 31 | cos(latitude) * sin(longitude), 32 | sin(latitude), 33 | cos(latitude) * cos(longitude)); 34 | } 35 | 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) 7 | { 8 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/texture.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | 3 | namespace glm 4 | { 5 | template 6 | inline T levels(vec const& Extent) 7 | { 8 | return glm::log2(compMax(Extent)) + static_cast(1); 9 | } 10 | 11 | template 12 | inline T levels(T Extent) 13 | { 14 | return vec<1, T, defaultp>(Extent).x; 15 | } 16 | }//namespace glm 17 | 18 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) 7 | { 8 | return translate(mat<4, 4, T, Q>(static_cast(1)), v); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) 13 | { 14 | return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) 19 | { 20 | return scale(mat<4, 4, T, Q>(static_cast(1)), v); 21 | } 22 | 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/wrap.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_wrap GLM_GTX_wrap 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../ext/scalar_common.hpp" 18 | #include "../ext/vector_common.hpp" 19 | #include "../gtc/vec1.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # ifndef GLM_ENABLE_EXPERIMENTAL 23 | # pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 24 | # else 25 | # pragma message("GLM: GLM_GTX_wrap extension included") 26 | # endif 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_wrap 32 | /// @{ 33 | 34 | /// @} 35 | }// namespace glm 36 | 37 | #include "wrap.inl" 38 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x2.hpp" 6 | #include "./ext/matrix_double2x2_precision.hpp" 7 | #include "./ext/matrix_float2x2.hpp" 8 | #include "./ext/matrix_float2x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x3.hpp" 6 | #include "./ext/matrix_double2x3_precision.hpp" 7 | #include "./ext/matrix_float2x3.hpp" 8 | #include "./ext/matrix_float2x3_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x4.hpp" 6 | #include "./ext/matrix_double2x4_precision.hpp" 7 | #include "./ext/matrix_float2x4.hpp" 8 | #include "./ext/matrix_float2x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x2.hpp" 6 | #include "./ext/matrix_double3x2_precision.hpp" 7 | #include "./ext/matrix_float3x2.hpp" 8 | #include "./ext/matrix_float3x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x3.hpp" 6 | #include "./ext/matrix_double3x3_precision.hpp" 7 | #include "./ext/matrix_float3x3.hpp" 8 | #include "./ext/matrix_float3x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x4.hpp" 6 | #include "./ext/matrix_double3x4_precision.hpp" 7 | #include "./ext/matrix_float3x4.hpp" 8 | #include "./ext/matrix_float3x4_precision.hpp" 9 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x2.hpp" 6 | #include "./ext/matrix_double4x2_precision.hpp" 7 | #include "./ext/matrix_float4x2.hpp" 8 | #include "./ext/matrix_float4x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x3.hpp" 6 | #include "./ext/matrix_double4x3_precision.hpp" 7 | #include "./ext/matrix_float4x3.hpp" 8 | #include "./ext/matrix_float4x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/mat4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x4.hpp" 6 | #include "./ext/matrix_double4x4_precision.hpp" 7 | #include "./ext/matrix_float4x4.hpp" 8 | #include "./ext/matrix_float4x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/simd/exponential.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/experimental.h 3 | 4 | #pragma once 5 | 6 | #include "platform.h" 7 | 8 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/simd/packing.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/packing.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/simd/trigonometric.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/trigonometric.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/simd/vector_relational.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/vector_relational.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool2.hpp" 6 | #include "./ext/vector_bool2_precision.hpp" 7 | #include "./ext/vector_float2.hpp" 8 | #include "./ext/vector_float2_precision.hpp" 9 | #include "./ext/vector_double2.hpp" 10 | #include "./ext/vector_double2_precision.hpp" 11 | #include "./ext/vector_int2.hpp" 12 | #include "./ext/vector_int2_sized.hpp" 13 | #include "./ext/vector_uint2.hpp" 14 | #include "./ext/vector_uint2_sized.hpp" 15 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool3.hpp" 6 | #include "./ext/vector_bool3_precision.hpp" 7 | #include "./ext/vector_float3.hpp" 8 | #include "./ext/vector_float3_precision.hpp" 9 | #include "./ext/vector_double3.hpp" 10 | #include "./ext/vector_double3_precision.hpp" 11 | #include "./ext/vector_int3.hpp" 12 | #include "./ext/vector_int3_sized.hpp" 13 | #include "./ext/vector_uint3.hpp" 14 | #include "./ext/vector_uint3_sized.hpp" 15 | -------------------------------------------------------------------------------- /thirdparty/glm/source/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool4.hpp" 6 | #include "./ext/vector_bool4_precision.hpp" 7 | #include "./ext/vector_float4.hpp" 8 | #include "./ext/vector_float4_precision.hpp" 9 | #include "./ext/vector_double4.hpp" 10 | #include "./ext/vector_double4_precision.hpp" 11 | #include "./ext/vector_int4.hpp" 12 | #include "./ext/vector_int4_sized.hpp" 13 | #include "./ext/vector_uint4.hpp" 14 | #include "./ext/vector_uint4_sized.hpp" 15 | 16 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json-3.11.2/CITATION.cff: -------------------------------------------------------------------------------- 1 | cff-version: 1.2.0 2 | message: "If you use this software, please cite it as below." 3 | authors: 4 | - family-names: Lohmann 5 | given-names: Niels 6 | orcid: https://orcid.org/0000-0001-9037-795X 7 | email: mail@nlohmann.me 8 | website: https://nlohmann.me 9 | title: "JSON for Modern C++" 10 | version: 3.11.2 11 | date-released: 2022-08-12 12 | license: MIT 13 | repository-code: "https://github.com/nlohmann" 14 | url: https://json.nlohmann.me 15 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json-3.11.2/include/nlohmann/detail/meta/call_std/begin.hpp: -------------------------------------------------------------------------------- 1 | // __ _____ _____ _____ 2 | // __| | __| | | | JSON for Modern C++ 3 | // | | |__ | | | | | | version 3.11.2 4 | // |_____|_____|_____|_|___| https://github.com/nlohmann/json 5 | // 6 | // SPDX-FileCopyrightText: 2013-2022 Niels Lohmann 7 | // SPDX-License-Identifier: MIT 8 | 9 | #pragma once 10 | 11 | #include 12 | 13 | NLOHMANN_JSON_NAMESPACE_BEGIN 14 | 15 | NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); 16 | 17 | NLOHMANN_JSON_NAMESPACE_END 18 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json-3.11.2/include/nlohmann/detail/meta/call_std/end.hpp: -------------------------------------------------------------------------------- 1 | // __ _____ _____ _____ 2 | // __| | __| | | | JSON for Modern C++ 3 | // | | |__ | | | | | | version 3.11.2 4 | // |_____|_____|_____|_|___| https://github.com/nlohmann/json 5 | // 6 | // SPDX-FileCopyrightText: 2013-2022 Niels Lohmann 7 | // SPDX-License-Identifier: MIT 8 | 9 | #pragma once 10 | 11 | #include 12 | 13 | NLOHMANN_JSON_NAMESPACE_BEGIN 14 | 15 | NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); 16 | 17 | NLOHMANN_JSON_NAMESPACE_END 18 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json-3.11.2/include/nlohmann/detail/meta/identity_tag.hpp: -------------------------------------------------------------------------------- 1 | // __ _____ _____ _____ 2 | // __| | __| | | | JSON for Modern C++ 3 | // | | |__ | | | | | | version 3.11.2 4 | // |_____|_____|_____|_|___| https://github.com/nlohmann/json 5 | // 6 | // SPDX-FileCopyrightText: 2013-2022 Niels Lohmann 7 | // SPDX-License-Identifier: MIT 8 | 9 | #pragma once 10 | 11 | #include 12 | 13 | NLOHMANN_JSON_NAMESPACE_BEGIN 14 | namespace detail 15 | { 16 | 17 | // dispatching helper struct 18 | template struct identity_tag {}; 19 | 20 | } // namespace detail 21 | NLOHMANN_JSON_NAMESPACE_END 22 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json-3.11.2/include/nlohmann/detail/meta/std_fs.hpp: -------------------------------------------------------------------------------- 1 | // __ _____ _____ _____ 2 | // __| | __| | | | JSON for Modern C++ 3 | // | | |__ | | | | | | version 3.11.2 4 | // |_____|_____|_____|_|___| https://github.com/nlohmann/json 5 | // 6 | // SPDX-FileCopyrightText: 2013-2022 Niels Lohmann 7 | // SPDX-License-Identifier: MIT 8 | 9 | #pragma once 10 | 11 | #include 12 | 13 | #if JSON_HAS_EXPERIMENTAL_FILESYSTEM 14 | #include 15 | NLOHMANN_JSON_NAMESPACE_BEGIN 16 | namespace detail 17 | { 18 | namespace std_fs = std::experimental::filesystem; 19 | } // namespace detail 20 | NLOHMANN_JSON_NAMESPACE_END 21 | #elif JSON_HAS_FILESYSTEM 22 | #include 23 | NLOHMANN_JSON_NAMESPACE_BEGIN 24 | namespace detail 25 | { 26 | namespace std_fs = std::filesystem; 27 | } // namespace detail 28 | NLOHMANN_JSON_NAMESPACE_END 29 | #endif 30 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json-3.11.2/include/nlohmann/detail/meta/void_t.hpp: -------------------------------------------------------------------------------- 1 | // __ _____ _____ _____ 2 | // __| | __| | | | JSON for Modern C++ 3 | // | | |__ | | | | | | version 3.11.2 4 | // |_____|_____|_____|_|___| https://github.com/nlohmann/json 5 | // 6 | // SPDX-FileCopyrightText: 2013-2022 Niels Lohmann 7 | // SPDX-License-Identifier: MIT 8 | 9 | #pragma once 10 | 11 | #include 12 | 13 | NLOHMANN_JSON_NAMESPACE_BEGIN 14 | namespace detail 15 | { 16 | 17 | template struct make_void 18 | { 19 | using type = void; 20 | }; 21 | template using void_t = typename make_void::type; 22 | 23 | } // namespace detail 24 | NLOHMANN_JSON_NAMESPACE_END 25 | -------------------------------------------------------------------------------- /thirdparty/renderdoc/renderdoc/api/README.md: -------------------------------------------------------------------------------- 1 | This folder can be extracted out and placed into your source tree if you want to use RenderDoc. 2 | 3 | * If you want to access RenderDoc while it's injected into your program, the app/ folder is what you want. This also contains functions for injecting RenderDoc into existing or new processes. 4 | * If you want to write a program that utilises RenderDoc's replay and analysis capabilities (e.g. writing a new UI, or an auto-testing/offline analysis tool), the replay/ folder is what you want. 5 | 6 | You will need both folders if you want to launch processes with RenderDoc injected. 7 | --------------------------------------------------------------------------------