├── .gitattributes
├── .gitignore
├── .gthub-media
    ├── nuro-example-1.jpg
    └── nuro_banner.jpg
├── CMakeLists.txt
├── CMakePresets.json
├── LICENSE
├── README.md
├── nuro-core
    ├── CMakeLists.txt
    ├── audio
    │   ├── audio_buffer.cpp
    │   ├── audio_buffer.h
    │   ├── audio_clip.cpp
    │   ├── audio_clip.h
    │   ├── audio_context.cpp
    │   ├── audio_context.h
    │   ├── audio_data.cpp
    │   ├── audio_data.h
    │   ├── audio_device.cpp
    │   ├── audio_device.h
    │   ├── audio_info.h
    │   ├── audio_listener.cpp
    │   ├── audio_listener.h
    │   ├── audio_samples.h
    │   ├── audio_source.cpp
    │   └── audio_source.h
    ├── backend
    │   └── api.h
    ├── context
    │   ├── application_context.cpp
    │   └── application_context.h
    ├── diagnostics
    │   ├── diagnostics.cpp
    │   ├── diagnostics.h
    │   ├── profiler.cpp
    │   └── profiler.h
    ├── ecs
    │   ├── components.h
    │   ├── ecs.cpp
    │   ├── ecs.h
    │   ├── ecs_collection.h
    │   ├── ecs_reflection.cpp
    │   ├── ecs_reflection.h
    │   └── entity_container.h
    ├── engine.h
    ├── input
    │   ├── cursor.cpp
    │   ├── cursor.h
    │   ├── input.cpp
    │   └── input.h
    ├── memory
    │   ├── resource.h
    │   ├── resource_manager.cpp
    │   ├── resource_manager.h
    │   └── resource_pipe.h
    ├── misc
    │   └── stb_image.cpp
    ├── physics
    │   ├── core
    │   │   ├── physics_bridge.cpp
    │   │   ├── physics_bridge.h
    │   │   ├── physics_context.cpp
    │   │   └── physics_context.h
    │   ├── physics.h
    │   ├── rigidbody
    │   │   ├── rigidbody.cpp
    │   │   ├── rigidbody.h
    │   │   └── rigidbody_enums.h
    │   └── utils
    │   │   ├── px_translator.cpp
    │   │   └── px_translator.h
    ├── rendering
    │   ├── culling
    │   │   ├── bounding_volume.cpp
    │   │   └── bounding_volume.h
    │   ├── gizmos
    │   │   ├── gizmo_color.h
    │   │   ├── gizmos.h
    │   │   ├── imgizmo.cpp
    │   │   └── imgizmo.h
    │   ├── icons
    │   │   ├── icon_pool.cpp
    │   │   └── icon_pool.h
    │   ├── material
    │   │   ├── imaterial.h
    │   │   ├── lit
    │   │   │   ├── lit_material.cpp
    │   │   │   └── lit_material.h
    │   │   └── unlit
    │   │   │   ├── unlit_material.cpp
    │   │   │   └── unlit_material.h
    │   ├── model
    │   │   ├── mesh.cpp
    │   │   ├── mesh.h
    │   │   ├── model.cpp
    │   │   └── model.h
    │   ├── passes
    │   │   ├── forward_pass.cpp
    │   │   ├── forward_pass.h
    │   │   ├── pre_pass.cpp
    │   │   ├── pre_pass.h
    │   │   ├── ssao_pass.cpp
    │   │   └── ssao_pass.h
    │   ├── postprocessing
    │   │   ├── bloom_pass.cpp
    │   │   ├── bloom_pass.h
    │   │   ├── motion_blur_pass.cpp
    │   │   ├── motion_blur_pass.h
    │   │   ├── post_processing.h
    │   │   ├── post_processing_pipeline.cpp
    │   │   └── post_processing_pipeline.h
    │   ├── primitives
    │   │   ├── global_quad.cpp
    │   │   ├── global_quad.h
    │   │   ├── shapes.cpp
    │   │   └── shapes.h
    │   ├── shader
    │   │   ├── shader.cpp
    │   │   ├── shader.h
    │   │   ├── shader_pool.cpp
    │   │   └── shader_pool.h
    │   ├── shadows
    │   │   ├── shadow_disk.cpp
    │   │   ├── shadow_disk.h
    │   │   ├── shadow_map.cpp
    │   │   └── shadow_map.h
    │   ├── skybox
    │   │   ├── cubemap.cpp
    │   │   ├── cubemap.h
    │   │   ├── skybox.cpp
    │   │   └── skybox.h
    │   ├── texture
    │   │   ├── texture.cpp
    │   │   └── texture.h
    │   ├── transformation
    │   │   ├── transformation.cpp
    │   │   └── transformation.h
    │   └── velocitybuffer
    │   │   ├── velocity_buffer.cpp
    │   │   └── velocity_buffer.h
    ├── scene
    │   ├── scene.cpp
    │   ├── scene.h
    │   ├── scene_manager.cpp
    │   └── scene_manager.h
    ├── shaders
    │   ├── gizmo
    │   │   ├── gizmo_fill
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   └── gizmo_icon
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   ├── legacy
    │   │   └── lit_legacy
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   ├── materials
    │   │   ├── lit
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── mat_unavailable
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── skybox
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   └── unlit
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   ├── passes
    │   │   ├── pre_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   └── shadow_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   ├── postprocessing
    │   │   ├── bloom_downsampling
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── bloom_prefilter
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── bloom_upsampling
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── debug_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── final_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── motion_blur_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── ssao_blur
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── ssao_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   ├── velocity_pass
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   │   └── velocity_postfilter
    │   │   │   ├── .frag
    │   │   │   └── .vert
    │   └── startup
    │   │   ├── startup_background
    │   │       ├── .frag
    │   │       └── .vert
    │   │   └── startup_model
    │   │       ├── .frag
    │   │       └── .vert
    ├── time
    │   ├── time.cpp
    │   └── time.h
    ├── transform
    │   ├── transform.cpp
    │   ├── transform.h
    │   ├── transform_pass.cpp
    │   └── transform_pass.h
    ├── utils
    │   ├── callback.h
    │   ├── concurrent_queue.h
    │   ├── console.cpp
    │   ├── console.h
    │   ├── event.h
    │   ├── format.cpp
    │   ├── format.h
    │   ├── fsutil.cpp
    │   ├── fsutil.h
    │   ├── guid.cpp
    │   ├── guid.h
    │   ├── string_helper.cpp
    │   └── string_helper.h
    └── viewport
    │   ├── viewport.cpp
    │   └── viewport.h
├── nuro-editor
    ├── CMakeLists.txt
    ├── assetsys
    │   ├── asset_meta.cpp
    │   ├── asset_meta.h
    │   ├── editor_asset.h
    │   ├── fallback_asset.cpp
    │   ├── fallback_asset.h
    │   ├── font_asset.cpp
    │   ├── font_asset.h
    │   ├── texture_asset.cpp
    │   └── texture_asset.h
    ├── gizmos
    │   ├── component_gizmos.cpp
    │   ├── component_gizmos.h
    │   └── editor_gizmo_color.h
    ├── imgui
    │   ├── ImGuizmo.cpp
    │   ├── ImGuizmo.h
    │   ├── README.md
    │   ├── imconfig.h
    │   ├── imgui.cpp
    │   ├── imgui.h
    │   ├── imgui_demo.cpp
    │   ├── imgui_draw.cpp
    │   ├── imgui_impl_glfw.cpp
    │   ├── imgui_impl_glfw.h
    │   ├── imgui_impl_opengl3.cpp
    │   ├── imgui_impl_opengl3.h
    │   ├── imgui_impl_opengl3_loader.h
    │   ├── imgui_internal.h
    │   ├── imgui_tables.cpp
    │   ├── imgui_widgets.cpp
    │   ├── implot.cpp
    │   ├── implot.h
    │   ├── implot_demo.cpp
    │   ├── implot_internal.h
    │   ├── implot_items.cpp
    │   ├── imstb_rectpack.h
    │   ├── imstb_textedit.h
    │   ├── imstb_truetype.h
    │   ├── textselect.cpp
    │   └── textselect.hpp
    ├── main.cpp
    ├── pipelines
    │   ├── game_view_pipeline.cpp
    │   ├── game_view_pipeline.h
    │   ├── preview_pipeline.cpp
    │   ├── preview_pipeline.h
    │   ├── scene_view_forward_pass.cpp
    │   ├── scene_view_forward_pass.h
    │   ├── scene_view_pipeline.cpp
    │   └── scene_view_pipeline.h
    ├── project
    │   ├── project_assets.cpp
    │   ├── project_assets.h
    │   ├── project_manager.cpp
    │   ├── project_manager.h
    │   ├── project_observer.cpp
    │   └── project_observer.h
    ├── reflection
    │   ├── asset_registry.cpp
    │   ├── asset_registry.h
    │   ├── component_registry.cpp
    │   └── component_registry.h
    ├── runtime
    │   ├── runtime.cpp
    │   └── runtime.h
    ├── testing
    │   ├── game_logic.cpp
    │   └── game_logic.h
    ├── ui
    │   ├── collection
    │   │   └── IconsFontAwesome6.h
    │   ├── components
    │   │   ├── im_components.cpp
    │   │   ├── im_components.h
    │   │   ├── inspectable_components.cpp
    │   │   ├── inspectable_components.h
    │   │   ├── toggle_bar.cpp
    │   │   └── toggle_bar.h
    │   ├── context_menu
    │   │   ├── context_menu.cpp
    │   │   └── context_menu.h
    │   ├── dynamic_drawing
    │   │   ├── draw_alignments.h
    │   │   ├── dynamic_content.cpp
    │   │   ├── dynamic_content.h
    │   │   ├── dynamic_text.cpp
    │   │   └── dynamic_text.h
    │   ├── editor_ui.cpp
    │   ├── editor_ui.h
    │   ├── footer
    │   │   ├── footer.cpp
    │   │   └── footer.h
    │   ├── inspectables
    │   │   ├── asset_inspectable.cpp
    │   │   ├── asset_inspectable.h
    │   │   ├── entity_inspectable.cpp
    │   │   ├── entity_inspectable.h
    │   │   ├── inspectable.h
    │   │   ├── welcome_inspectable.cpp
    │   │   └── welcome_inspectable.h
    │   ├── search
    │   │   ├── search_popup.cpp
    │   │   └── search_popup.h
    │   ├── title_bar
    │   │   ├── title_bar.cpp
    │   │   └── title_bar.h
    │   ├── utils
    │   │   ├── ui_utils.cpp
    │   │   └── ui_utils.h
    │   └── windows
    │   │   ├── asset_browser_window.cpp
    │   │   ├── asset_browser_window.h
    │   │   ├── audio_setup_window.cpp
    │   │   ├── audio_setup_window.h
    │   │   ├── console_window.cpp
    │   │   ├── console_window.h
    │   │   ├── diagnostics_window.cpp
    │   │   ├── diagnostics_window.h
    │   │   ├── editor_window.h
    │   │   ├── game_window.cpp
    │   │   ├── game_window.h
    │   │   ├── insight_panel_window.cpp
    │   │   ├── insight_panel_window.h
    │   │   ├── post_processing_window.cpp
    │   │   ├── post_processing_window.h
    │   │   ├── registry_window.cpp
    │   │   ├── registry_window.h
    │   │   ├── resource_viewer_window.cpp
    │   │   ├── resource_viewer_window.h
    │   │   ├── viewport_window.cpp
    │   │   └── viewport_window.h
    └── utfcpp
    │   ├── README.md
    │   ├── utf8.h
    │   └── utf8
    │       ├── checked.h
    │       ├── core.h
    │       ├── cpp11.h
    │       ├── cpp17.h
    │       ├── cpp20.h
    │       └── unchecked.h
├── resources
    ├── editor-examples
    │   └── empty-project
    │   │   ├── .project
    │   │   └── assets
    │   │       └── .gitkeep
    ├── fonts
    │   ├── Icons
    │   │   ├── LICENSE.txt
    │   │   └── fa-solid-900-free.ttf
    │   └── Inter
    │   │   ├── Inter_18pt-ExtraLight.ttf
    │   │   ├── Inter_18pt-Light.ttf
    │   │   ├── Inter_18pt-Regular.ttf
    │   │   ├── Inter_18pt-SemiBold.ttf
    │   │   ├── Inter_18pt-Thin.ttf
    │   │   └── LICENSE.txt
    ├── icons
    │   ├── assets
    │   │   ├── file.png
    │   │   ├── folder.png
    │   │   ├── font.png
    │   │   ├── material.png
    │   │   ├── script.png
    │   │   └── texture.png
    │   ├── components
    │   │   ├── audio_listener.png
    │   │   ├── audio_source.png
    │   │   ├── box_collider.png
    │   │   ├── camera.png
    │   │   ├── directional_light.png
    │   │   ├── mesh_collider.png
    │   │   ├── mesh_renderer.png
    │   │   ├── point_light.png
    │   │   ├── rigidbody.png
    │   │   ├── sphere_collider.png
    │   │   ├── spotlight.png
    │   │   ├── transform.png
    │   │   └── velocity_blur.png
    │   ├── fallback
    │   │   ├── fallback_icon.png
    │   │   └── fallback_texture.png
    │   ├── misc
    │   │   └── listener_active.png
    │   ├── post-processing
    │   │   ├── ambient_occlusion.png
    │   │   ├── bloom.png
    │   │   ├── chromatic_aberration.png
    │   │   ├── color.png
    │   │   ├── motion_blur.png
    │   │   └── vignette.png
    │   ├── scene
    │   │   ├── audio_source_gizmo.png
    │   │   ├── camera_gizmo.png
    │   │   ├── directional_light_gizmo.png
    │   │   ├── point_light_gizmo.png
    │   │   └── spotlight_gizmo.png
    │   └── shared
    │   │   ├── failed.png
    │   │   └── logo.png
    ├── layouts
    │   └── imgui.ini
    └── primitives
    │   ├── cube.fbx
    │   ├── plane.fbx
    │   ├── sphere.fbx
    │   └── sphere_lowpoly.fbx
├── vcpkg-configuration.json
└── vcpkg.json


/.gitattributes:
--------------------------------------------------------------------------------
 1 | # C++ source and header files
 2 | *.cpp    text
 3 | *.h      text
 4 | *.hpp    text
 5 | # Object files, compiled binaries, and static libraries
 6 | *.o      binary
 7 | *.obj    binary
 8 | *.a      binary
 9 | *.lib    binary
10 | *.dll    binary
11 | # CMake and build system files
12 | CMakeLists.txt text
13 | *.cmake   text
14 | Makefile  text
15 | # Asset files (handled as binary)
16 | *.ttf    binary
17 | *.otf    binary
18 | *.png    binary
19 | *.jpg    binary
20 | *.jpeg   binary
21 | *.gif    binary
22 | *.bmp    binary
23 | *.tga    binary
24 | *.dds    binary
25 | *.hdr    binary
26 | *.psd    binary
27 | *.raw    binary
28 | *.fbx    binary
29 | *.obj    binary
30 | *.dae    binary
31 | *.3ds    binary
32 | *.blend  binary
33 | # Ignore temporary and IDE specific files
34 | .vscode/* binary
35 | .idea/*   binary
36 | *.user    binary
37 | *.swp     binary
38 | # Miscellaneous
39 | *.log    text
40 | *.md     text
41 | resources/**/*.png filter=lfs diff=lfs merge=lfs -text
42 | resources/**/*.fbx filter=lfs diff=lfs merge=lfs -text
43 | resources/**/*.jpg filter=lfs diff=lfs merge=lfs -text
44 | resources/**/*.ttf filter=lfs diff=lfs merge=lfs -text
45 | resources/**/*.otf filter=lfs diff=lfs merge=lfs -text
46 | 


--------------------------------------------------------------------------------
/.gthub-media/nuro-example-1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonkwl/nuro/60039f25f36d71950eeb53e230cc72495f037d9d/.gthub-media/nuro-example-1.jpg


--------------------------------------------------------------------------------
/.gthub-media/nuro_banner.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonkwl/nuro/60039f25f36d71950eeb53e230cc72495f037d9d/.gthub-media/nuro_banner.jpg


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.10)
 2 | 
 3 | project(nuro CXX)
 4 | 
 5 | set(CMAKE_CXX_STANDARD 20)
 6 | 
 7 | # core
 8 | find_package(assimp CONFIG REQUIRED) 
 9 | find_package(EnTT CONFIG REQUIRED)
10 | find_package(glad CONFIG REQUIRED)
11 | find_package(glfw3 CONFIG REQUIRED)
12 | find_package(glm CONFIG REQUIRED)
13 | find_package(Stb REQUIRED)
14 | find_package(nlohmann_json CONFIG REQUIRED)
15 | find_package(unofficial-omniverse-physx-sdk CONFIG REQUIRED)
16 | find_package(FFMPEG REQUIRED)
17 | find_package(OpenAL CONFIG REQUIRED)
18 | find_package(reflectcpp CONFIG REQUIRED)
19 | 
20 | # editor
21 | find_package(efsw CONFIG REQUIRED)
22 | 
23 | add_subdirectory(nuro-core)
24 | add_subdirectory(nuro-editor)


--------------------------------------------------------------------------------
/CMakePresets.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": 2,
 3 |   "configurePresets": [
 4 |     {
 5 |       "name": "windows-default",
 6 |       "generator": "Visual Studio 17 2022",
 7 |       "binaryDir": "${sourceDir}/build",
 8 |       "cacheVariables": {
 9 |         "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
10 |       }
11 |     }
12 |   ],
13 |   "buildPresets": [
14 |     {
15 | 	  "name": "windows-default",
16 | 	  "configurePreset": "windows-default"
17 |     }
18 |   ]
19 | }


--------------------------------------------------------------------------------
/nuro-core/audio/audio_buffer.cpp:
--------------------------------------------------------------------------------
 1 | #include "audio_buffer.h"
 2 | 
 3 | #include <AL/alc.h>
 4 | 
 5 | #include <utils/console.h>
 6 | 
 7 | AudioBuffer::AudioBuffer() : _id(0),
 8 | _loaded(false)
 9 | {
10 | }
11 | 
12 | AudioBuffer::~AudioBuffer()
13 | {
14 | 	destroy();
15 | }
16 | 
17 | bool AudioBuffer::create(AudioSamples& samples)
18 | {
19 | 	ALuint bufferId;
20 | 	alGenBuffers(1, &bufferId);
21 | 	if (alGetError() != AL_NO_ERROR) {
22 | 		Console::out::warning("Audio Buffer", "Couldn't create audio buffer");
23 | 		return false;
24 | 	}
25 | 
26 | 	alBufferData(bufferId, samples.getAlFormat(), samples.getSamples(), samples.getSize(), samples.getSampleRate());
27 | 	if (alGetError() != AL_NO_ERROR) {
28 | 		Console::out::warning("Audio Buffer", "Couldn't load audio data into buffer");
29 | 		return false;
30 | 	}
31 | 
32 | 	_id = static_cast<uint32_t>(bufferId);
33 | 	_loaded = true;
34 | 
35 | 	return true;
36 | }
37 | 
38 | void AudioBuffer::destroy()
39 | {
40 | 	if (_id) alDeleteBuffers(1, &_id);
41 | 	_id = 0;
42 | 	_loaded = false;
43 | }
44 | 
45 | uint32_t AudioBuffer::id() const
46 | {
47 | 	return _id;
48 | }
49 | 
50 | bool AudioBuffer::loaded() const
51 | {
52 | 	return _loaded;
53 | }
54 | 


--------------------------------------------------------------------------------
/nuro-core/audio/audio_buffer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <cstdint>
 5 | #include <AL/al.h>
 6 | 
 7 | #include <audio/audio_samples.h>
 8 | 
 9 | class AudioBuffer {
10 | public:
11 | 	AudioBuffer();
12 | 	~AudioBuffer();
13 | 
14 | 	// Uploads an audio buffer with the given audio samples
15 | 	bool create(AudioSamples& samples);
16 | 
17 | 	// Deletes uploaded audio buffer if any
18 | 	void destroy();
19 | 
20 | 	// Returns the audio buffers backend id
21 | 	uint32_t id() const;
22 | 
23 | 	// Returns if the audio buffer is loaded
24 | 	bool loaded() const;
25 | 
26 | private:
27 | 	uint32_t _id;
28 | 	bool _loaded;
29 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_clip.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory/resource.h>
 4 | #include <audio/audio_info.h>
 5 | #include <audio/audio_data.h>
 6 | #include <audio/audio_buffer.h>
 7 | 
 8 | class AudioClip : public Resource
 9 | {
10 | public:
11 | 	AudioClip();
12 | 	~AudioClip() override;
13 | 
14 | 	// Default pipe for creating audio clip
15 | 	ResourcePipe create() {
16 | 		return std::move(pipe()
17 | 			>> BIND_TASK(AudioClip, loadIoData)
18 | 			>> BIND_TASK_WITH_FLAGS(AudioClip, uploadBuffers, TaskFlags::UseContextThread));
19 | 	}
20 | 
21 | 	// Sets the path of the audio clips data source
22 | 	void setSource(const std::string& path);
23 | 
24 | 	// Returns a readonly reference to the audio clips info
25 | 	const AudioInfo& info() const;
26 | 
27 | 	// Returns a readonly reference to the audio clips data
28 | 	const AudioData& data() const;
29 | 
30 | 	// Returns a readonly reference to the audio clips mono buffer
31 | 	const AudioBuffer& monoBuffer() const;
32 | 
33 | 	// Returns a readonly reference to the audio clips multichannel buffer
34 | 	const AudioBuffer& multichannelBuffer() const;
35 | 
36 | 	// Returns if the multichannel buffer is available
37 | 	bool multichannelAvailable() const;
38 | 
39 | 	// Prints information about the audio clip
40 | 	void printInfo() const;
41 | 
42 | private:
43 | 	bool loadIoData();
44 | 	void freeIoData();
45 | 	bool uploadBuffers();
46 | 	void deleteBuffers();
47 | 
48 | 	AudioInfo _info;
49 | 	AudioData _data;	
50 | 
51 | 	AudioBuffer _monoBuffer;
52 | 	AudioBuffer _multichannelBuffer;
53 | 
54 | 	bool _multichannelAvailable;
55 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_context.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | 
 6 | #include <audio/audio_device.h>
 7 | #include <ecs/ecs_collection.h>
 8 | 
 9 | class ALCcontext;
10 | 
11 | class AudioContext 
12 | {
13 | public:
14 | 	AudioContext();
15 | 
16 | 	// Creates audio context
17 | 	void create();
18 | 
19 | 	// Destroys the current audio context if any
20 | 	void destroy();
21 | 
22 | 	// Updates the audio context
23 | 	void update();
24 | 
25 | 	// Returns the audio device
26 | 	const AudioDevice& device() const;
27 | 
28 | 	// Returns if stereo angles are available
29 | 	bool stereoAnglesAvailable() const;
30 | 
31 | 	// Returns if effects are available
32 | 	bool effectsAvailable() const;
33 | 
34 | 	// Returns if float32 format is available
35 | 	bool floatFmtAvailable() const;
36 | 
37 | 	// Returns if multichannel formats are available
38 | 	bool multichannelFmtAvailable() const;
39 | 
40 | 	// Returns if B-format is available
41 | 	bool bFmtAvailable() const;
42 | 
43 | 	// Returns if B-format higher order ambisonics are available
44 | 	bool bHoaFmtAvailable() const;
45 | 
46 | 	// Returns if hrtf is available
47 | 	bool hrtfAvailable() const;
48 | 
49 | 	// Returns name of hrtf function being used
50 | 	const std::string& usedHrtf() const;
51 | 
52 | 	// Returns the names of all hrtf functions available
53 | 	const std::vector<std::string>& hrtfFunctions() const;
54 | 
55 | 	// Handles any audio backend errors if any
56 | 	static void backendError();
57 | 
58 | public:
59 | 	// (ECS Bridge Callback) Constructs an audio source in backend
60 | 	static void constructAudioSource(Registry& reg, Entity ent);
61 | 
62 | 	// (ECS Bridge Callback) Destroys an audio source in backend
63 | 	static void destroyAudioSource(Registry& reg, Entity ent);
64 | 
65 | private:
66 | 	void setupHrtf();
67 | 
68 | 	ALCcontext* _context;
69 | 	AudioDevice _device;
70 | 
71 | 	bool stereoAngles;
72 | 	bool effects;
73 | 
74 | 	bool floatFmt;
75 | 	bool multichannelFmt;
76 | 	bool bFmt;
77 | 	bool bHoaFmt;
78 | 
79 | 	bool hrtf;
80 | 	std::vector<std::string> hrtfList;
81 | 	std::string activeHrtf;
82 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_data.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | #include <cstdint>
 6 | #include <AL/al.h>
 7 | #include <type_traits>
 8 | 
 9 | extern "C"
10 | {
11 | #include <libavcodec/avcodec.h>
12 | #include <libavformat/avformat.h>
13 | #include <libswresample/swresample.h>
14 | }
15 | 
16 | #include <utils/fsutil.h>
17 | #include <audio/audio_info.h>
18 | #include <audio/audio_samples.h>
19 | 
20 | class AudioData 
21 | {
22 | public:
23 | 	AudioData();
24 | 	~AudioData();
25 | 
26 | 	// Sets the path of the audio source file
27 | 	void setSource(const FS::Path& sourcePath);
28 | 
29 | 	// Loads the audio data from the current source and sets audio info
30 | 	bool load(AudioInfo& info);
31 | 
32 | 	// Frees any loaded audio data
33 | 	void free();
34 | 
35 | 	// Returns the loaded pcm single channel samples (nullptr if not available)
36 | 	AudioSamples* monoSamples() const;
37 | 
38 | 	// Returns the loaded pcm multichannel samples (nullptr if not available)
39 | 	AudioSamples* multichannelSamples() const;
40 | 
41 | 	// Returns the current audio source file path
42 | 	const FS::Path& sourcePath() const;
43 | 
44 | private:
45 | 	// Decodes an audio stream into pcm samples, target layout and format provided by samples reference
46 | 	bool decodeInto(AudioSamples* samples, AVFormatContext*& formatContext, AVCodecContext*& codecContext, SwrContext*& swrContext, int streamIndex) const;
47 | 
48 | 	// Returns the channel layout for the provided amount of channels
49 | 	AVChannelLayout getLayout_by_nChannels(int32_t nChannels) const;
50 | 
51 | 	// Returns the channel layout for a provided channel layout mask
52 | 	AVChannelLayout getLayout_by_mask(uint64_t mask) const;
53 | 
54 | 	// Handles process fail
55 | 	bool fail(std::string info) const;
56 | 
57 | 	// Validates the current source path
58 | 	bool validateSource() const;
59 | 
60 | 	FS::Path _sourcePath;
61 | 
62 | 	AudioSamples* _monoSamples;
63 | 	AudioSamples* _multichannelSamples;
64 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_device.cpp:
--------------------------------------------------------------------------------
 1 | #include "audio_device.h"
 2 | 
 3 | #include <AL/al.h>
 4 | #include <AL/alc.h>
 5 | 
 6 | #include <audio/audio_context.h>
 7 | 
 8 | AudioDevice::AudioDevice() : _handle(nullptr),
 9 | _opened(false),
10 | _hardwareDevices(),
11 | _usedHardware("System Default")
12 | {
13 | }
14 | 
15 | bool AudioDevice::create()
16 | {
17 | 	_opened = false;
18 | 	_hardwareDevices.clear();
19 | 
20 | 	// Open default device
21 | 	_handle = alcOpenDevice(nullptr);
22 | 	if (!_handle) {
23 | 		AudioContext::backendError();
24 | 		return false;
25 | 	}
26 | 	_opened = true;
27 | 
28 | 	// Try to fetch hardware devices
29 | 	bool defaultDeviceOnly = true;
30 | 	if (alcIsExtensionPresent(nullptr, "ALC_ENUMERATE_ALL_EXT")) {
31 | 		const ALCchar* devices = alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER);
32 | 		if (devices) {
33 | 			defaultDeviceOnly = false;
34 | 			while (*devices) {
35 | 				// Extract hardware device name
36 | 				std::string deviceName(devices);
37 | 				const std::string prefix = "OpenAL Soft on ";
38 | 				if (deviceName.rfind(prefix, 0) == 0) {
39 | 					deviceName = deviceName.substr(prefix.length());
40 | 				}
41 | 
42 | 				// Add hardware device name
43 | 				_hardwareDevices.emplace_back(deviceName);
44 | 				devices += strlen(devices) + 1;
45 | 			}
46 | 		}
47 | 	}
48 | 	if (defaultDeviceOnly) _hardwareDevices.push_back("Default");
49 | 
50 | 	return true;
51 | }
52 | 
53 | void AudioDevice::destroy()
54 | {
55 | 	if (!_handle) return;
56 | 
57 | 	alcCloseDevice(_handle);
58 | 	_handle = nullptr;
59 | 	_opened = false;
60 | }
61 | 
62 | bool AudioDevice::opened() const
63 | {
64 | 	return _opened;
65 | }
66 | 
67 | const std::vector<std::string>& AudioDevice::hardwareDevices() const
68 | {
69 | 	return _hardwareDevices;
70 | }
71 | 
72 | const std::string& AudioDevice::usedHardware() const {
73 | 	return _usedHardware;
74 | }
75 | 
76 | ALCdevice* AudioDevice::handle()
77 | {
78 | 	return _handle;
79 | }


--------------------------------------------------------------------------------
/nuro-core/audio/audio_device.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | 
 6 | class ALCdevice;
 7 | 
 8 | class AudioDevice 
 9 | {
10 | public:
11 | 	AudioDevice();
12 | 
13 | 	// Creates audio device
14 | 	bool create();
15 | 
16 | 	// Closes the current audio device if any
17 | 	void destroy();
18 | 
19 | 	// Returns if a device is opened
20 | 	bool opened() const;
21 | 
22 | 	// Returns the currently fetched hardware devices
23 | 	const std::vector<std::string>& hardwareDevices() const;
24 | 
25 | 	// Returns the name of the hardware device currently being used
26 | 	const std::string& usedHardware() const;
27 | 
28 | 	// Return the current ausdio device handle (nullptr if none)
29 | 	ALCdevice* handle();
30 | 
31 | private:
32 | 	ALCdevice* _handle;
33 | 	bool _opened;
34 | 	std::vector<std::string> _hardwareDevices;
35 | 	std::string _usedHardware;
36 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_info.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <cstdint>
 5 | #include <unordered_map>
 6 | 
 7 | extern "C"
 8 | {
 9 | #include <libavcodec/avcodec.h>
10 | #include <libavformat/avformat.h>
11 | #include <libswresample/swresample.h>
12 | }
13 | 
14 | struct AudioInfo {
15 | 
16 | 	// String representation of path to audio file
17 | 	std::string path = "None";
18 | 
19 | 	//  Audio files name
20 | 	std::string name = "Unnamed";
21 | 
22 | 	// File format
23 | 	std::string fileFormat = "Invalid";
24 | 
25 | 	// Audio codec
26 | 	std::string codec = "Invalid";
27 | 
28 | 	// Samples per second
29 | 	int32_t sampleRate = 0;
30 | 
31 | 	// Number of audio channels
32 | 	int32_t nChannels = 0;
33 | 
34 |     // Format of the audio samples within the file
35 |     AVSampleFormat sampleFormat;
36 | 
37 | 	// Bitrate in bit/s
38 | 	int32_t bitrate = 0;
39 | 
40 | 	// Duration in seconds
41 | 	double duration = 0.0;
42 | 
43 | 	// Metadata
44 | 	std::unordered_map<std::string, std::string> metadata;
45 | 
46 |     // Convert sample format to string
47 |     std::string formatToStr(AVSampleFormat sampleFormat) const {
48 |         switch (sampleFormat) {
49 |         case AV_SAMPLE_FMT_U8:
50 |             return "Unsigned 8-bit Integer";
51 |         case AV_SAMPLE_FMT_S16:
52 |             return "Signed 16-bit Integer";
53 |         case AV_SAMPLE_FMT_S32:
54 |             return "Signed 32-bit Integer";
55 |         case AV_SAMPLE_FMT_FLT:
56 |             return "32-bit Floating Point";
57 |         case AV_SAMPLE_FMT_DBL:
58 |             return "64-bit Floating Point";
59 |         case AV_SAMPLE_FMT_U8P:
60 |             return "Unsigned 8-bit Integer Planar";
61 |         case AV_SAMPLE_FMT_S16P:
62 |             return "Signed 16-bit Integer Planar";
63 |         case AV_SAMPLE_FMT_S32P:
64 |             return "Signed 32-bit Integer Planar";
65 |         case AV_SAMPLE_FMT_FLTP:
66 |             return "32-bit Floating Point Planar";
67 |         case AV_SAMPLE_FMT_DBLP:
68 |             return "64-bit Floating Point Planar";
69 |         case AV_SAMPLE_FMT_S64:
70 |             return "Signed 64-bit Integer";
71 |         case AV_SAMPLE_FMT_S64P:
72 |             return "Signed 64-bit Integer Planar";
73 |         default:
74 |             return "Unknown Format";
75 |         }
76 |     }
77 | 
78 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_listener.cpp:
--------------------------------------------------------------------------------
1 | #include "audio_listener.h"


--------------------------------------------------------------------------------
/nuro-core/audio/audio_listener.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | class AudioListener {
4 | 
5 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_samples.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <al/al.h>
 4 | 
 5 | extern "C"
 6 | {
 7 | #include <libavcodec/avcodec.h>
 8 | #include <libavformat/avformat.h>
 9 | #include <libswresample/swresample.h>
10 | }
11 | 
12 | class AudioSamples {
13 | public:
14 | 	virtual ~AudioSamples() = default;
15 | 
16 | 	virtual int32_t getSampleRate() const = 0;
17 | 	virtual AVChannelLayout getAvTargetLayout() const = 0;
18 | 	virtual AVSampleFormat getAvTargetFormat() const = 0;
19 | 	virtual ALenum getAlFormat() const = 0;
20 | 
21 | 	virtual void* getSamples() = 0;
22 | 	virtual size_t getSize() const = 0;
23 | 	virtual void insertSamples(const void* start, const void* end) = 0;
24 | };
25 | 
26 | template <typename T>
27 | class AudioSamplesBuffer : public AudioSamples {
28 | public:
29 | 	AudioSamplesBuffer(int32_t sampleRate, AVChannelLayout avTargetLayout, AVSampleFormat avTargetFormat, ALenum alFormat)
30 | 		: sampleRate(sampleRate), avTargetLayout(avTargetLayout), avTargetFormat(avTargetFormat), alFormat(alFormat)
31 | 	{
32 | 	}
33 | 
34 | 	// Returns the sample rate of the samples
35 | 	int32_t getSampleRate() const override {
36 | 		return sampleRate;
37 | 	}
38 | 
39 | 	// Returns the ffmpeg target channel layout when decoding the audio samples
40 | 	AVChannelLayout getAvTargetLayout() const override {
41 | 		return avTargetLayout;
42 | 	}
43 | 
44 | 	// Returns the ffmpeg target format when decoding the audio samples
45 | 	AVSampleFormat getAvTargetFormat() const override {
46 | 		return avTargetFormat;
47 | 	}
48 | 
49 | 	// Returns the audio backend format when buffer the audio samples
50 | 	ALenum getAlFormat() const override {
51 | 		return alFormat;
52 | 	}
53 | 
54 | 	// Returns a pointer to the raw pcm samples
55 | 	void* getSamples() override {
56 | 		return samples.data();
57 | 	}
58 | 
59 | 	// Returns the size of the samples
60 | 	size_t getSize() const override {
61 | 		return samples.size() * sizeof(T);
62 | 	}
63 | 
64 | 	// Inserts a range of samples
65 | 	void insertSamples(const void* start, const void* end) override {
66 | 		const T* typedStart = static_cast<const T*>(start);
67 | 		const T* typedEnd = static_cast<const T*>(end);
68 | 		samples.insert(samples.end(), typedStart, typedEnd);
69 | 	}
70 | 
71 | private:
72 | 	const int32_t sampleRate;
73 | 	const AVChannelLayout avTargetLayout;
74 | 	const AVSampleFormat avTargetFormat;
75 | 	const ALenum alFormat;
76 | 
77 | 	std::vector<T> samples;
78 | };


--------------------------------------------------------------------------------
/nuro-core/audio/audio_source.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <ecs/components.h>
 4 | #include <memory/resource_manager.h>
 5 | 
 6 | class AudioClip;
 7 | 
 8 | namespace AudioSource {
 9 | 
10 |     enum State {
11 |         PLAYING,
12 |         PAUSED,
13 |         STOPPED
14 |     };
15 | 
16 |     // Set gain (volume)
17 |     void setVolume(AudioSourceComponent& audioSource, float volume);
18 | 
19 |     // Set pitch
20 |     void setPitch(AudioSourceComponent& audioSource, float pitch);
21 | 
22 |     // Enables or disables looping
23 |     void setLooping(AudioSourceComponent& audioSource, bool looping);
24 | 
25 |     // Makes the source use 3D spatial audio or not
26 |     void setIsSpatial(AudioSourceComponent& audioSource, bool spatial);
27 | 
28 |     // Set max distance (cutoff for attenuation)
29 |     void setRange(AudioSourceComponent& audioSource, float range);
30 | 
31 |     // Set rolloff factor (attenuation curve)
32 |     void setFalloff(AudioSourceComponent& audioSource, float falloff);
33 | 
34 |     // Set inner cone angle (area of normal sound)
35 |     void setConeInnerAngle(AudioSourceComponent& audioSource, float angle);
36 | 
37 |     // Set outer cone angle (area where sound fades)
38 |     void setConeOuterAngle(AudioSourceComponent& audioSource, float angle);
39 | 
40 |     // Set outer cone gain (volume reduction outside cone)
41 |     void setConeOuterVolume(AudioSourceComponent& audioSource, float volume);
42 | 
43 |     // Sets the clip of an audio source
44 |     void setClip(AudioSourceComponent& audioSource, ResourceRef<AudioClip> clip);
45 | 
46 |     // Syncs all settings of an audio source
47 |     void sync(AudioSourceComponent& audioSource);
48 | 
49 |     // Returns the state of an audio source
50 |     State getState(AudioSourceComponent& audioSource);
51 | 
52 |     // Starts the playback
53 |     void play(AudioSourceComponent& audioSource, float offset = 0.0f);
54 | 
55 |     // Pauses the playback
56 |     void pause(AudioSourceComponent& audioSource);
57 | 
58 |     // Stops the playback
59 |     void stop(AudioSourceComponent& audioSource);
60 | 
61 |     // Continues the playback where it last stopped
62 |     void resume(AudioSourceComponent& audioSource);
63 | 
64 |     // Returns the current playback offset
65 |     float getOffset(AudioSourceComponent& audioSource);
66 | 
67 |     // Sets the current playback offset
68 |     void setOffset(AudioSourceComponent& audioSource, float offset);
69 | 
70 | };


--------------------------------------------------------------------------------
/nuro-core/backend/api.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | enum class API {
4 | 	NONE,
5 | 	OPENGL
6 | };


--------------------------------------------------------------------------------
/nuro-core/context/application_context.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include <backend/api.h>
 7 | #include <audio/audio_context.h>
 8 | #include <memory/resource_manager.h>
 9 | #include <physics/core/physics_context.h>
10 | 
11 | struct GLFWwindow;
12 | struct GLFWmonitor;
13 | 
14 | namespace ApplicationContext
15 | {
16 | 	// Represents the configuration settings for an application context
17 | 	struct Configuration {
18 | 		API api = API::NONE;
19 | 		std::string windowTitle = "Runtime";
20 | 		glm::ivec2 windowSize = glm::vec2(1280, 720);
21 | 		glm::ivec2 windowPosition = glm::vec2(0, 0);
22 | 		bool fullscreen = false;
23 | 		bool menubarVisible = true;
24 | 		bool vsync = true;
25 | 		bool resizeable = true;
26 | 		bool visible = true;
27 | 	};
28 | 
29 | 	// Creates application context with given configuration
30 | 	void create(Configuration configuration);
31 | 
32 | 	// Destroys application context
33 | 	void destroy();
34 | 
35 | 	// Begins a new frame
36 | 	void nextFrame();
37 | 
38 | 	// Ends a frame
39 | 	void endFrame();
40 | 
41 | 	// Returns if application is still running
42 | 	bool running();
43 | 
44 | 	// Resizes window
45 | 	void resizeWindow(glm::ivec2 size);
46 | 
47 | 	// Maximizes window
48 | 	void maximizeWindow();
49 | 
50 | 	// Minimizes (iconifies) window
51 | 	void minimizeWindow();
52 | 
53 | 	// Sets window to fullscreen
54 | 	void setFullscreen();
55 | 
56 | 	// Sets window to windowed with last saved window size
57 | 	void setWindowed();
58 | 
59 | 	// Sets if window is resizeable
60 | 	void setResizeable(bool value);
61 | 
62 | 	// Updates the windows menu bar visibility
63 | 	void setMenubarVisibility(bool value);
64 | 
65 | 	// Updates the vsync configuration option
66 | 	void setVSync(bool value);
67 | 
68 | 	// Shows or hides the window
69 | 	void setVisible(bool value);
70 | 
71 | 	// Sets position of window on the screen
72 | 	void setPosition(glm::ivec2 position);
73 | 
74 | 	// Returns position of window on the screen
75 | 	glm::ivec2 getPosition();
76 | 
77 | 	// Returns size of screen
78 | 	glm::ivec2 getScreenSize();
79 | 
80 | 	// Returns a pointer to the applications window
81 | 	GLFWwindow* getWindow();
82 | 
83 | 	// Returns a readonly reference to the currently active configuration
84 | 	const Configuration& readConfiguration();
85 | 
86 | 	// Returns the audio context
87 | 	AudioContext& audioContext();
88 | 
89 | 	// Returns the physics context
90 | 	PhysicsContext& physicsContext();
91 | 
92 | 	// Returns the resource manager
93 | 	ResourceManager& resourceManager();
94 | 
95 | };


--------------------------------------------------------------------------------
/nuro-core/diagnostics/diagnostics.cpp:
--------------------------------------------------------------------------------
  1 | #include "diagnostics.h"
  2 | 
  3 | #include <time/time.h>
  4 | 
  5 | namespace Diagnostics {
  6 | 
  7 | 	float gFps = 0.0f;
  8 | 	float gAverageFps = 0.0f;
  9 | 	float gAverageFpsUpdateTime = 1.0f; // Duration of each fps period
 10 | 	float gAverageFpsFrameCount = 0.0f; // Frame counter for average fps calculation
 11 | 	float gAverageFpsElapsedTime = 0.0f; // Elapsed time since beginning of last fps period
 12 | 
 13 | 	uint32_t gCurrentDrawCalls = 0;
 14 | 	uint32_t gCurrentVertices = 0;
 15 | 	uint32_t gCurrentPolygons = 0;
 16 | 
 17 | 	uint32_t gNCPUEntities = 0;
 18 | 	uint32_t gNGPUEntities = 0;
 19 | 
 20 | 	void step()
 21 | 	{
 22 | 		float delta = Time::unscaledDeltaf();
 23 | 
 24 | 		// Reset frame based diagnostics
 25 | 		gCurrentDrawCalls = 0;
 26 | 		gCurrentVertices = 0;
 27 | 		gCurrentPolygons = 0;
 28 | 
 29 | 		gNCPUEntities = 0;
 30 | 		gNGPUEntities = 0;
 31 | 
 32 | 		// Calculate current fps
 33 | 		gFps = 1.0 / delta;
 34 | 
 35 | 		// Calculate current average fps
 36 | 		gAverageFpsElapsedTime += delta;
 37 | 		gAverageFpsFrameCount += 1.0f;
 38 | 		if (gAverageFpsElapsedTime >= gAverageFpsUpdateTime)
 39 | 		{
 40 | 			gAverageFps = gAverageFpsFrameCount / gAverageFpsElapsedTime;
 41 | 			gAverageFpsElapsedTime = 0.0f;
 42 | 			gAverageFpsFrameCount = 0;
 43 | 		}
 44 | 	}
 45 | 
 46 | 	const float getFps()
 47 | 	{
 48 | 		return gFps;
 49 | 	}
 50 | 
 51 | 	const float getAverageFps()
 52 | 	{
 53 | 		return gAverageFps;
 54 | 	}
 55 | 
 56 | 	const uint32_t getCurrentDrawCalls()
 57 | 	{
 58 | 		return gCurrentDrawCalls;
 59 | 	}
 60 | 
 61 | 	const uint32_t getCurrentVertices()
 62 | 	{
 63 | 		return gCurrentVertices;
 64 | 	}
 65 | 
 66 | 	const uint32_t getCurrentPolygons()
 67 | 	{
 68 | 		return gCurrentPolygons;
 69 | 	}
 70 | 
 71 | 	const uint32_t getNEntitiesCPU()
 72 | 	{
 73 | 		return gNCPUEntities;
 74 | 	}
 75 | 
 76 | 	const uint32_t getNEntitiesGPU()
 77 | 	{
 78 | 		return gNGPUEntities;
 79 | 	}
 80 | 
 81 | 	const void addCurrentDrawCalls(const uint32_t increment)
 82 | 	{
 83 | 		gCurrentDrawCalls += increment;
 84 | 	}
 85 | 
 86 | 	const void addCurrentVertices(const uint32_t increment)
 87 | 	{
 88 | 		gCurrentVertices += increment;
 89 | 	}
 90 | 
 91 | 	const void addCurrentPolygons(const uint32_t increment)
 92 | 	{
 93 | 		gCurrentPolygons += increment;
 94 | 	}
 95 | 
 96 | 	const void addNEntitiesCPU(const uint32_t increment)
 97 | 	{
 98 | 		gNCPUEntities += increment;
 99 | 	}
100 | 
101 | 	const void addNEntitiesGPU(const uint32_t increment)
102 | 	{
103 | 		gNGPUEntities += increment;
104 | 	}
105 | 
106 | }


--------------------------------------------------------------------------------
/nuro-core/diagnostics/diagnostics.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | namespace Diagnostics
 6 | {
 7 | 
 8 | 	void step(); // Prepares diagnostics for next frame
 9 | 
10 | 	const float getFps(); // Current fps
11 | 	const float getAverageFps(); // Average fps of last fps period
12 | 
13 | 	const uint32_t getCurrentDrawCalls(); // Draw calls issued this frame
14 | 	const uint32_t getCurrentVertices(); // Vertices rendered this frame
15 | 	const uint32_t getCurrentPolygons(); // Polygons rendered this frame
16 | 	const uint32_t getNEntitiesCPU(); // Entities handled on the cpu this frame
17 | 	const uint32_t getNEntitiesGPU(); // Entities handled on the gpu this frame
18 | 
19 | 	const void addCurrentDrawCalls(const uint32_t increment);
20 | 	const void addCurrentVertices(const uint32_t increment);
21 | 	const void addCurrentPolygons(const uint32_t increment);
22 | 	const void addNEntitiesCPU(const uint32_t increment);
23 | 	const void addNEntitiesGPU(const uint32_t increment);
24 | 
25 | };


--------------------------------------------------------------------------------
/nuro-core/diagnostics/profiler.cpp:
--------------------------------------------------------------------------------
 1 | #include "profiler.h"
 2 | 
 3 | namespace Profiler
 4 | {
 5 | 
 6 | 	std::unordered_map<std::string, std::chrono::steady_clock::time_point> gProfiles = std::unordered_map<std::string, std::chrono::steady_clock::time_point>();
 7 | 	std::unordered_map<std::string, double> gTimes = std::unordered_map<std::string, double>();
 8 | 
 9 | 	bool _validateProfile(const std::string& identifier)
10 | 	{
11 | 		return gProfiles.find(identifier) == gProfiles.end() ? false : true;
12 | 	}
13 | 
14 | 	bool _validateTime(const std::string& identifier)
15 | 	{
16 | 		return gTimes.find(identifier) == gTimes.end() ? false : true;
17 | 	}
18 | 
19 | 	std::chrono::steady_clock::time_point _now()
20 | 	{
21 | 		return std::chrono::high_resolution_clock::now();
22 | 	}
23 | 
24 | 	void start(const std::string& identifier)
25 | 	{
26 | 		gProfiles[identifier] = _now();
27 | 	}
28 | 
29 | 	double stop(const std::string& identifier)
30 | 	{
31 | 		if (!_validateProfile(identifier))
32 | 		{
33 | 			return 0.0;
34 | 		}
35 | 		double time = std::chrono::duration<double, std::micro>(_now() - gProfiles[identifier]).count();
36 | 		gTimes[identifier] = time;
37 | 		return time;
38 | 	}
39 | 
40 | 	double getMs(const std::string& identifier)
41 | 	{
42 | 		if (!_validateTime(identifier)) return 0.0f;
43 | 		return gTimes[identifier] * 0.001;
44 | 	}
45 | 
46 | 	double getUs(const std::string& identifier)
47 | 	{
48 | 		if (!_validateTime(identifier)) return 0.0f;
49 | 		return gTimes[identifier];
50 | 	}
51 | 
52 | 	double getNs(const std::string& identifier)
53 | 	{
54 | 		if (!_validateTime(identifier)) return 0.0f;
55 | 		return gTimes[identifier] * 1000;
56 | 	}
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------
/nuro-core/diagnostics/profiler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <chrono>
 5 | #include <unordered_map>
 6 | 
 7 | namespace Profiler
 8 | {
 9 | 
10 | 	// Creates new profile for given identifier and starts profiling
11 | 	void start(const std::string& identifier);
12 | 
13 | 	// Stops profiling for given identifier and returns time
14 | 	double stop(const std::string& identifier);
15 | 
16 | 	// Returns last cached time for given identifier in milliseconds
17 | 	double getMs(const std::string& identifier);
18 | 
19 | 	// Returns last cached time for given identifier in microseconds
20 | 	double getUs(const std::string& identifier);
21 | 
22 | 	// Returns last cached time for given identifier in nanoseconds
23 | 	double getNs(const std::string& identifier);
24 | 
25 | };


--------------------------------------------------------------------------------
/nuro-core/ecs/ecs_collection.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Collection of ecs related includes
4 | 
5 | #include <entt/entt.hpp>
6 | 
7 | #include <ecs/ecs.h>
8 | #include <ecs/components.h>
9 | #include <ecs/entity_container.h>


--------------------------------------------------------------------------------
/nuro-core/ecs/ecs_reflection.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <entt/entt.hpp>
 4 | #include <nlohmann/json.hpp>
 5 | 
 6 | using json = nlohmann::ordered_json;
 7 | 
 8 | namespace ECSReflection {
 9 | 
10 | 	// Registers all types and their associated reflection metadata
11 | 	void registerAll();
12 | 
13 | 	// Serializes an ecs component instance to json
14 | 	json serializeComponent(entt::meta_any instance);
15 | 
16 | 	// Deserializes a json component emplacing it onto the given entity
17 | 	bool deserializeComponent(entt::entity entity, const json& source);
18 | 
19 | }


--------------------------------------------------------------------------------
/nuro-core/engine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // Useful includes for applications using engine
 4 | #include <glm/glm.hpp>
 5 | #include <time/time.h>
 6 | #include <input/input.h>
 7 | #include <input/cursor.h>
 8 | #include <utils/console.h>
 9 | #include <physics/physics.h>
10 | #include <audio/audio_clip.h>
11 | #include <audio/audio_source.h>
12 | #include <ecs/ecs_collection.h>
13 | #include <transform/transform.h>
14 | #include <diagnostics/profiler.h>
15 | #include <glm/gtc/quaternion.hpp>
16 | #include <rendering/model/model.h>
17 | #include <rendering/gizmos/gizmos.h>
18 | #include <rendering/skybox/skybox.h>
19 | #include <memory/resource_manager.h>
20 | #include <rendering/texture/texture.h>
21 | #include <context/application_context.h>
22 | #include <rendering/primitives/shapes.h>
23 | #include <rendering/material/lit/lit_material.h>
24 | #include <rendering/material/unlit/unlit_material.h>
25 | #include <rendering/postprocessing/post_processing.h>


--------------------------------------------------------------------------------
/nuro-core/input/cursor.cpp:
--------------------------------------------------------------------------------
 1 | #include "cursor.h"
 2 | 
 3 | #include <utils/console.h>
 4 | #include <context/application_context.h>
 5 | 
 6 | namespace Cursor {
 7 | 
 8 | 	GLFWwindow* gWindow;
 9 | 
10 | 	void setup()
11 | 	{
12 | 		gWindow = ApplicationContext::getWindow();
13 | 	}
14 | 
15 | 	glm::vec2 getPosition()
16 | 	{
17 | 		double mouseX = 0.0, mouseY = 0.0;
18 | 		glfwGetCursorPos(gWindow, &mouseX, &mouseY);
19 | 		return glm::vec2(mouseX, mouseY);
20 | 	}
21 | 
22 | 	glm::vec2 getScreenPosition()
23 | 	{
24 | 		// Get cursor position on window
25 | 		double mouseX, mouseY;
26 | 		glfwGetCursorPos(gWindow, &mouseX, &mouseY);
27 | 
28 | 		// Get windows position on screen
29 | 		int windowPosX, windowPosY;
30 | 		glfwGetWindowPos(gWindow, &windowPosX, &windowPosY);
31 | 
32 | 		// Calculate cursor position relative to the screen
33 | 		double screenX = windowPosX + mouseX;
34 | 		double screenY = windowPosY + mouseY;
35 | 
36 | 		return glm::vec2(screenX, screenY);
37 | 	}
38 | 
39 | 	void setPosition(glm::vec2 position)
40 | 	{
41 | 		glfwSetCursorPos(gWindow, position.x, position.y);
42 | 	}
43 | 
44 | 	void setType(uint32_t cursorType)
45 | 	{
46 | 		glfwSetCursor(gWindow, glfwCreateStandardCursor(cursorType));
47 | 	}
48 | 
49 | 	void setMode(uint32_t cursorMode)
50 | 	{
51 | 		glfwSetInputMode(gWindow, GLFW_CURSOR, cursorMode);
52 | 	}
53 | 
54 | 	void center()
55 | 	{
56 | 		int32_t windowWidth, windowHeight;
57 | 		glfwGetWindowSize(gWindow, &windowWidth, &windowHeight);
58 | 		glm::vec2 cursorPosition = glm::vec2(windowWidth / 2.0f, windowHeight / 2.0f);
59 | 		glfwSetCursorPos(gWindow, cursorPosition.x, cursorPosition.y);
60 | 	}
61 | 
62 | }
63 | 


--------------------------------------------------------------------------------
/nuro-core/input/cursor.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include <glad/glad.h>
 7 | #include <GLFW/glfw3.h>
 8 | 
 9 | namespace Cursor
10 | {
11 | 
12 |     // Sets up cursor
13 | 	void setup();
14 | 
15 |     // Returns the current cursor position relative to window
16 | 	glm::vec2 getPosition();
17 | 
18 |     // Returns the current cursor position relative to screen
19 |     glm::vec2 getScreenPosition();
20 | 
21 |     // Sets the cursor position relative to window
22 | 	void setPosition(glm::vec2 position);
23 | 
24 |     // Sets cursor type
25 | 	void setType(uint32_t cursorType);
26 | 
27 |     // Sets cursor mode
28 | 	void setMode(uint32_t cursorMode);
29 | 
30 |     // Centers the cursor relative to window
31 | 	void center();
32 | 
33 | };
34 | 
35 | namespace CursorType {
36 | 
37 |     static constexpr uint32_t DEFAULT = GLFW_ARROW_CURSOR;
38 |     static constexpr uint32_t HAND = GLFW_HAND_CURSOR;
39 |     static constexpr uint32_t POINTER = GLFW_POINTING_HAND_CURSOR;
40 |     static constexpr uint32_t TEXT_CARET = GLFW_IBEAM_CURSOR;
41 |     static constexpr uint32_t CROSSHAIR = GLFW_CROSSHAIR_CURSOR;
42 |     static constexpr uint32_t RESIZE_HORIZONTAL = GLFW_HRESIZE_CURSOR;
43 |     static constexpr uint32_t RESIZE_VERTICAL = GLFW_VRESIZE_CURSOR;
44 |     static constexpr uint32_t RESIZE_EW = GLFW_RESIZE_EW_CURSOR;
45 |     static constexpr uint32_t RESIZE_NS = GLFW_RESIZE_NS_CURSOR;
46 |     static constexpr uint32_t RESIZE_NWSE = GLFW_RESIZE_NWSE_CURSOR;
47 |     static constexpr uint32_t RESIZE_NESW = GLFW_RESIZE_NESW_CURSOR;
48 |     static constexpr uint32_t RESIZE_ALL = GLFW_RESIZE_ALL_CURSOR;
49 |     static constexpr uint32_t NOT_ALLOWED = GLFW_NOT_ALLOWED_CURSOR;
50 | 
51 | }
52 | 
53 | namespace CursorMode {
54 |     static constexpr uint32_t NORMAL = GLFW_CURSOR_NORMAL;
55 |     static constexpr uint32_t HIDDEN = GLFW_CURSOR_HIDDEN;
56 |     static constexpr uint32_t UNAVAILABLE = GLFW_CURSOR_DISABLED;
57 |     static constexpr uint32_t CONFINED = GLFW_CURSOR_CAPTURED;
58 |     static constexpr uint32_t LOCKED = GLFW_CURSOR_DISABLED;
59 | };


--------------------------------------------------------------------------------
/nuro-core/input/input.cpp:
--------------------------------------------------------------------------------
  1 | #include "input.h"
  2 | 
  3 | #include <glad/glad.h>
  4 | #include <GLFW/glfw3.h>
  5 | 
  6 | #include <context/application_context.h>
  7 | 
  8 | namespace Input {
  9 | 
 10 | 	GLFWwindow* gWindow = nullptr;
 11 | 
 12 | 	glm::vec2 gMoveAxis = glm::vec2(0.0f);
 13 | 
 14 | 	glm::vec2 gMouseDelta = glm::vec2(0.0f);
 15 | 	glm::vec2 gMouseLast = glm::vec2(0.0f);
 16 | 
 17 | 	glm::vec2 gScrollOffset = glm::vec2(0.0f);
 18 | 
 19 | 	// Context callbacks
 20 | 
 21 | 	void _scrollCallback(GLFWwindow* window, double xoffset, double yoffset)
 22 | 	{
 23 | 		gScrollOffset = glm::vec2(xoffset, yoffset);
 24 | 	}
 25 | 
 26 | 	// Input functions
 27 | 
 28 | 	void setup()
 29 | 	{
 30 | 		gWindow = ApplicationContext::getWindow();
 31 | 
 32 | 		double mouseX, mouseY;
 33 | 		glfwGetCursorPos(gWindow, &mouseX, &mouseY);
 34 | 		gMouseLast = glm::vec2(mouseX, mouseY);
 35 | 
 36 | 		glfwSetScrollCallback(gWindow, _scrollCallback);
 37 | 	}
 38 | 
 39 | 	void update()
 40 | 	{
 41 | 		// set mouse
 42 | 		double mouseX, mouseY;
 43 | 		glfwGetCursorPos(gWindow, &mouseX, &mouseY);
 44 | 		gMouseDelta = glm::vec2(mouseX - gMouseLast.x, -(mouseY - gMouseLast.y));
 45 | 		gMouseLast = glm::vec2(mouseX, mouseY);
 46 | 
 47 | 		if (glfwGetKey(gWindow, GLFW_KEY_W) == GLFW_PRESS)
 48 | 		{
 49 | 			gMoveAxis.x = 1.0f;
 50 | 		}
 51 | 		else if (glfwGetKey(gWindow, GLFW_KEY_S) == GLFW_PRESS)
 52 | 		{
 53 | 			gMoveAxis.x = -1.0f;
 54 | 		}
 55 | 		else
 56 | 		{
 57 | 			gMoveAxis.x = 0.0f;
 58 | 		}
 59 | 
 60 | 		if (glfwGetKey(gWindow, GLFW_KEY_D) == GLFW_PRESS)
 61 | 		{
 62 | 			gMoveAxis.y = 1.0f;
 63 | 		}
 64 | 		else if (glfwGetKey(gWindow, GLFW_KEY_A) == GLFW_PRESS)
 65 | 		{
 66 | 			gMoveAxis.y = -1.0f;
 67 | 		}
 68 | 		else
 69 | 		{
 70 | 			gMoveAxis.y = 0.0f;
 71 | 		}
 72 | 	}
 73 | 
 74 | 	// Getters
 75 | 
 76 | 	glm::vec2 moveAxis()
 77 | 	{
 78 | 		return gMoveAxis;
 79 | 	}
 80 | 
 81 | 	glm::vec2 mouseDelta()
 82 | 	{
 83 | 		return gMouseDelta;
 84 | 	}
 85 | 
 86 | 	glm::vec2 scrollDelta()
 87 | 	{
 88 | 		glm::vec2 scrollDelta = gScrollOffset;
 89 | 		gScrollOffset = glm::vec2(0.0f);
 90 | 		return scrollDelta;
 91 | 	}
 92 | 
 93 | 	glm::vec2 mousePosition()
 94 | 	{
 95 | 		double mouseX = 0.0, mouseY = 0.0;
 96 | 		glfwGetCursorPos(gWindow, &mouseX, &mouseY);
 97 | 		return glm::vec2(mouseX, mouseY);
 98 | 	}
 99 | 
100 | 	bool keyDown(int32_t key)
101 | 	{
102 | 		return glfwGetKey(gWindow, key) == GLFW_PRESS;
103 | 	}
104 | 
105 | 	bool mouseDown(int32_t mouseButton)
106 | 	{
107 | 		return glfwGetMouseButton(gWindow, mouseButton) == GLFW_PRESS;
108 | 	}
109 | 
110 | 	bool command(int32_t key)
111 | 	{
112 | 		return keyDown(Key::LEFT_CONTROL) && keyDown(key);
113 | 	}
114 | 
115 | }


--------------------------------------------------------------------------------
/nuro-core/memory/resource.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <atomic>
 5 | #include <cstdint>
 6 | 
 7 | #include <memory/resource_pipe.h>
 8 | 
 9 | using ResourceID = uint32_t;
10 | 
11 | enum class ResourceState {
12 | 	// Resource has not been initialized or loaded yet
13 | 	EMPTY,
14 | 
15 | 	// Resource is queued and waiting for asynchronous creation
16 | 	QUEUED,
17 | 
18 | 	// Resource is being loaded (e.g., loading data or being dispatched to the GPU)
19 | 	LOADING,
20 | 
21 | 	// Resource has been successfully loaded and is ready for use
22 | 	READY,
23 | 
24 | 	// Laoding resource failed
25 | 	FAILED
26 | };
27 | 
28 | class Resource
29 | {
30 | private:
31 | 	friend class ResourceManager;
32 | 
33 | 	// ID of the resource
34 | 	ResourceID _resourceId;
35 | 
36 | 	// Name of resource
37 | 	std::string _resourceName;
38 | 
39 | 	// State of the resource
40 | 	std::atomic<ResourceState> _resourceState;
41 | 
42 | protected:
43 | 	// Returns a new resource pipe owned by this resource
44 | 	ResourcePipe pipe() {
45 | 		return std::move(ResourcePipe(_resourceId));
46 | 	}
47 | 
48 | 	Resource() : _resourceId(0), _resourceName("none"), _resourceState(ResourceState::EMPTY) {};
49 | 
50 | public:
51 | 	virtual ~Resource() = 0;
52 | 
53 | 	// Returns the resources id
54 | 	ResourceID resourceId() const {
55 | 		return _resourceId;
56 | 	}
57 | 
58 | 	// Returns the resources id
59 | 	const std::string& resourceName() const {
60 | 		return _resourceName;
61 | 	}
62 | 
63 | 	// Returns the resources current state
64 | 	ResourceState resourceState() const {
65 | 		return _resourceState;
66 | 	}
67 | };
68 | 
69 | inline Resource::~Resource() {}


--------------------------------------------------------------------------------
/nuro-core/misc/stb_image.cpp:
--------------------------------------------------------------------------------
1 | #define STB_IMAGE_IMPLEMENTATION
2 | #include "stb_image.h"
3 | 
4 | #define STB_IMAGE_WRITE_IMPLEMENTATION
5 | #include "stb_image_write.h"


--------------------------------------------------------------------------------
/nuro-core/physics/core/physics_context.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glm/glm.hpp>
 4 | #include <PxPhysicsAPI.h>
 5 | #include <ecs/ecs_collection.h>
 6 | 
 7 | #include <physics/core/physics_bridge.h>
 8 | 
 9 | class PhysicsContext
10 | {
11 | public:
12 | 	PhysicsContext();
13 | 
14 | 	void create(); // Create physics
15 | 	void destroy(); // Destroy physics
16 | 
17 | 	// Steps physics and performs simulation iterations
18 | 	void step();
19 | 
20 | private:
21 | 	// Simulates physics iteration
22 | 	void simulate();
23 | 
24 | 	// Apply transform of physics rigidbody on given rigidbody component
25 | 	void syncRigidbodyComponent(RigidbodyComponent& rigidbody);
26 | 
27 | 	// Apply position and rotation of given rigidbody component to given transform component
28 | 	void syncTransformComponent(float delta, TransformComponent& transform, RigidbodyComponent& rigidbody);
29 | 
30 | 	glm::vec3 interpolate(glm::vec3 lastPosition, glm::vec3 position, float factor);
31 | 	glm::quat interpolate(glm::quat lastRotation, glm::quat rotation, float factor);
32 | 
33 | private:
34 | 	physx::PxDefaultAllocator allocator;
35 | 	physx::PxDefaultErrorCallback errorCallback;
36 | 	physx::PxFoundation* foundation;
37 | 	physx::PxPhysics* physics;
38 | 	physx::PxDefaultCpuDispatcher* dispatcher;
39 | 	physx::PxScene* scene;
40 | 	physx::PxPvd* pvd;
41 | 
42 | 	PhysicsBridge bridge;
43 | 
44 | 	const physx::PxReal timeStep;
45 | 	const physx::PxVec3 gravity;
46 | 	double accumulatedTime;
47 | 
48 | };


--------------------------------------------------------------------------------
/nuro-core/physics/physics.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Includes for accessing physics system
4 | #include <physics/rigidbody/rigidbody.h>
5 | #include <physics/utils/px_translator.h>
6 | #include <physics/core/physics_context.h>
7 | #include <physics/rigidbody/rigidbody_enums.h>


--------------------------------------------------------------------------------
/nuro-core/physics/rigidbody/rigidbody.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glm/glm.hpp>
 4 | 
 5 | #include <ecs/components.h>
 6 | #include <physics/rigidbody/rigidbody_enums.h>
 7 | 
 8 | namespace Rigidbody
 9 | {
10 | 
11 | 	// Checks if a rigidbody component is associated with a valid rigidbody
12 | 	bool validate(RigidbodyComponent& rigidbody);
13 | 
14 | 	// Sets interpolation of rigidbody
15 | 	void setInterpolation(RigidbodyComponent& rigidbody, RB_Interpolation interpolation);
16 | 
17 | 	// Sets collision detection of rigidbody
18 | 	void setCollisionDetection(RigidbodyComponent& rigidbody, RB_CollisionDetection collisionDetection);
19 | 
20 | 	// Sets resistance coefficient of rigidbody
21 | 	void setResistance(RigidbodyComponent& rigidbody, float resistance);
22 | 
23 | 	// Sets angular resistance coefficient of rigidbody
24 | 	void setAngularResistance(RigidbodyComponent& rigidbody, float angularResistance);
25 | 
26 | 	// Sets if rigidbody will be affected by gravity
27 | 	void setGravity(RigidbodyComponent& rigidbody, bool gravity);
28 | 
29 | 	// Sets if rigidbody should not be affected by physics
30 | 	void setKinematic(RigidbodyComponent& rigidbody, bool kinematic);
31 | 
32 | 	// Add force to rigidbody
33 | 	void addForce(RigidbodyComponent& rigidbody, glm::vec3 value, RB_ForceMode mode = RB_ForceMode::LINEAR);
34 | 
35 | 	// Add torque to rigidbody
36 | 	void addTorque(RigidbodyComponent& rigidbody, glm::vec3 value, RB_ForceMode mode);
37 | 
38 | };


--------------------------------------------------------------------------------
/nuro-core/physics/rigidbody/rigidbody_enums.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | enum class RB_Interpolation {
 4 | 	NONE,
 5 | 	INTERPOLATE,
 6 | 	EXTRAPOLATE
 7 | };
 8 | 
 9 | enum class RB_CollisionDetection {
10 | 	DISCRETE,
11 | 	CONTINUOUS,
12 | 	CONTINUOUS_SPECULATIVE
13 | };
14 | 
15 | enum class RB_ForceMode {
16 | 	LINEAR,
17 | 	IMPULSE,
18 | 	VELOCITY_CHANGE,
19 | 	ACCELERATION
20 | };


--------------------------------------------------------------------------------
/nuro-core/physics/utils/px_translator.cpp:
--------------------------------------------------------------------------------
 1 | #include "px_translator.h"
 2 | 
 3 | namespace PxTranslator {
 4 | 
 5 |     // Convert physx::PxVec2 to glm::vec2
 6 |     glm::vec2 convert(physx::PxVec2 input) {
 7 |         return glm::vec2(input.x, input.y);
 8 |     }
 9 | 
10 |     // Convert physx::PxVec3 to glm::vec3
11 |     glm::vec3 convert(physx::PxVec3 input) {
12 |         return glm::vec3(input.x, input.y, input.z);
13 |     }
14 | 
15 |     // Convert physx::PxVec4 to glm::vec4
16 |     glm::vec4 convert(physx::PxVec4 input) {
17 |         return glm::vec4(input.x, input.y, input.z, input.w);
18 |     }
19 | 
20 |     // Convert glm::vec2 to physx::PxVec2
21 |     physx::PxVec2 convert(glm::vec2 input) {
22 |         return physx::PxVec2(input.x, input.y);
23 |     }
24 | 
25 |     // Convert glm::vec3 to physx::PxVec3
26 |     physx::PxVec3 convert(glm::vec3 input) {
27 |         return physx::PxVec3(input.x, input.y, input.z);
28 |     }
29 | 
30 |     // Convert glm::vec4 to physx::PxVec4
31 |     physx::PxVec4 convert(glm::vec4 input) {
32 |         return physx::PxVec4(input.x, input.y, input.z, input.w);
33 |     }
34 | 
35 |     // Convert physx::PxQuat to glm::quat
36 |     glm::quat convert(physx::PxQuat input) {
37 |         if (!input.isFinite()) { // invalid input -> identity rotation
38 |             return glm::identity<glm::quat>();
39 |         }
40 |         return glm::quat(input.w, input.x, input.y, input.z);
41 |     }
42 | 
43 |     // Convert glm::quat to physx::PxQuat
44 |     physx::PxQuat convert(glm::quat input) {
45 |         glm::quat normalized = glm::normalize(input);
46 |         return physx::PxQuat(normalized.x, normalized.y, normalized.z, normalized.w);
47 |     }
48 | 
49 | }


--------------------------------------------------------------------------------
/nuro-core/physics/utils/px_translator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <PxPhysicsAPI.h>
 4 | #include <glm/glm.hpp>
 5 | #include <glm/gtc/quaternion.hpp>
 6 | 
 7 | namespace PxTranslator
 8 | {
 9 | 
10 | 	glm::vec2 convert(physx::PxVec2 input);
11 | 	glm::vec3 convert(physx::PxVec3 input);
12 | 	glm::vec4 convert(physx::PxVec4 input);
13 | 
14 | 	physx::PxVec2 convert(glm::vec2 input);
15 | 	physx::PxVec3 convert(glm::vec3 input);
16 | 	physx::PxVec4 convert(glm::vec4 input);
17 | 
18 | 	glm::quat convert(physx::PxQuat input);
19 | 	physx::PxQuat convert(glm::quat input);
20 | 
21 | };
22 | 
23 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/culling/bounding_volume.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glm/glm.hpp>
 4 | #include <glm/gtc/quaternion.hpp>
 5 | 
 6 | #include <rendering/gizmos/gizmos.h>
 7 | 
 8 | class Model;
 9 | 
10 | class BoundingVolume
11 | {
12 | public:
13 | 	virtual void update(Model* model, glm::vec3 position, glm::quat rotation, glm::vec3 scale) {};
14 | 	virtual bool intersectsFrustum() { return false; };
15 | 	virtual float getDistance(glm::vec3 point) { return 0.0f; }
16 | 	virtual void draw(IMGizmo& imGizmoInstance, glm::vec4 color) {};
17 | };
18 | 
19 | class BoundingSphere : public BoundingVolume
20 | {
21 | public:
22 | 	BoundingSphere();
23 | 
24 | 	void update(Model* model, glm::vec3 position, glm::quat rotation, glm::vec3 scale);
25 | 	bool intersectsFrustum();
26 | 	float getDistance(glm::vec3 point);
27 | 	void draw(IMGizmo& imGizmoInstance, glm::vec4 color);
28 | 
29 | 	glm::vec3 center;
30 | 	float radius;
31 | };
32 | 
33 | class BoundingAABB : public BoundingVolume
34 | {
35 | public:
36 | 	BoundingAABB();
37 | 
38 | 	void update(Model* model, glm::vec3 position, glm::quat rotation, glm::vec3 scale);
39 | 	bool intersectsFrustum();
40 | 	float getDistance(glm::vec3 point);
41 | 	void draw(IMGizmo& imGizmoInstance, glm::vec4 color);
42 | 
43 | 	glm::vec3 min;
44 | 	glm::vec3 max;
45 | };
46 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/gizmos/gizmos.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Collection of includes useful for when utilizing gizmos
4 | #include <rendering/gizmos/gizmo_color.h>
5 | #include <rendering/icons/icon_pool.h>
6 | #include <rendering/gizmos/imgizmo.h>


--------------------------------------------------------------------------------
/nuro-core/rendering/icons/icon_pool.cpp:
--------------------------------------------------------------------------------
 1 | #include "icon_pool.h"
 2 | 
 3 | #include <vector>
 4 | #include <stb_image.h>
 5 | #include <unordered_map>
 6 | 
 7 | #include <utils/console.h>
 8 | #include <memory/resource_manager.h>
 9 | #include <rendering/texture/texture.h>
10 | #include <context/application_context.h>
11 | 
12 | namespace IconPool {
13 | 
14 | 	// List of valid extensions for icon source files
15 | 	std::vector<FS::Path> gValidExtensions = { ".png", ".jpg", ".jpeg" };
16 | 
17 | 	// Global registry of all icons by their identifiers
18 | 	std::unordered_map<std::string, ResourceRef<Texture>> gIcons;
19 | 
20 | 	// Texture of fallback icon for invalid icons
21 | 	ResourceRef<Texture> gInvalidIcon;
22 | 
23 | 	void _loadAll(const FS::Path& directory, bool async)
24 | 	{
25 | 		ResourceManager& resource = ApplicationContext::resourceManager();
26 | 
27 | 		std::vector<FS::Path> files = FS::getFilesWithExtensions(directory, gValidExtensions);
28 | 		for (const auto& file : files) {
29 | 			// Get icon identifier
30 | 			std::string identifier = file.stem().string();
31 | 
32 | 			// Skip icon creation if it already exists
33 | 			if (gIcons.find(identifier) != gIcons.end()) continue;
34 | 
35 | 			// Create icon texture
36 | 			auto [textureId, texture] = resource.create<Texture>(identifier + "_icon");
37 | 			texture->setSource(TextureType::IMAGE, file);
38 | 
39 | 			// Insert new icon
40 | 			gIcons.insert({ identifier, texture });
41 | 
42 | 			// Load icon texture
43 | 			if (async) {
44 | 				resource.exec(texture->create());
45 | 			}
46 | 			else {
47 | 				resource.execAsDependency(texture->create());
48 | 			}
49 | 
50 | 		}
51 | 	}
52 | 
53 | 	void loadAllSync(const FS::Path& directory)
54 | 	{
55 | 		Console::out::info("Icon Pool", "Loading icons from '" + directory.string() + "'");
56 | 		_loadAll(directory, false);
57 | 	}
58 | 
59 | 	void loadAllAsync(const FS::Path& directory)
60 | 	{
61 | 		Console::out::info("Icon Pool", "Queued loading icons in '" + directory.string() + "'");
62 | 		_loadAll(directory, true);
63 | 	}
64 | 
65 | 	uint32_t get(const std::string& identifier)
66 | 	{
67 | 		if (auto it = gIcons.find(identifier); it != gIcons.end()) {
68 | 			// Icon found, return its backend id
69 | 			return it->second->backendId();
70 | 		}
71 | 		else {
72 | 			// Icon not found, return invalid icons backend id
73 | 			return gInvalidIcon->backendId();
74 | 		}
75 | 	}
76 | 
77 | 	void createFallbackIcon(const FS::Path& path)
78 | 	{
79 | 		ResourceManager& resource = ApplicationContext::resourceManager();
80 | 
81 | 		auto [textureId, texture] = resource.create<Texture>("fallback-icon");
82 | 		gInvalidIcon = texture;
83 | 		gInvalidIcon->setSource(TextureType::IMAGE, path);
84 | 
85 | 		resource.execAsDependency(texture->create());
86 | 	}
87 | 
88 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/icons/icon_pool.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | 
 5 | #include <utils/fsutil.h>
 6 | 
 7 | class Texture;
 8 | 
 9 | namespace IconPool {
10 | 	
11 | 	// Loads all icons from the given directory synchronously
12 | 	void loadAllSync(const FS::Path& directory);
13 | 
14 | 	// Loads all icons from the given directory asynchronously
15 | 	void loadAllAsync(const FS::Path& directory);
16 | 
17 | 	// Returns the texture backend id of an icon by the given identifier
18 | 	uint32_t get(const std::string& identifier);
19 | 
20 | 	// Creates a fallback icon for invalid icons synchronously
21 | 	void createFallbackIcon(const FS::Path& path);
22 | 
23 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/material/imaterial.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | #include <viewport/viewport.h>
 6 | #include <rendering/shader/shader.h>
 7 | #include <memory/resource_manager.h>
 8 | 
 9 | /* !!!!!!!!!!!!!!!!!!!!!!!!!!
10 |    !!					   !!
11 |    !! BAD TEMPORARY CODE!  !!
12 |    !!					   !!
13 |    !!!!!!!!!!!!!!!!!!!!!!!!!! */
14 | 
15 | class IMaterial
16 | {
17 | public:
18 | 	virtual ~IMaterial() {}
19 | 
20 | 	virtual void bind() const = 0;
21 | 	virtual uint32_t getId() const = 0;
22 | 	virtual ResourceRef<Shader> getShader() const = 0;
23 | 	virtual uint32_t getShaderId() const = 0;
24 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/material/lit/lit_material.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include "../imaterial.h"
 7 | 
 8 | #include <viewport/viewport.h>
 9 | #include <ecs/ecs_collection.h>
10 | #include <memory/resource_manager.h>
11 | #include <rendering/texture/texture.h>
12 | #include <rendering/postprocessing/post_processing.h>
13 | 
14 | class ShadowDisk;
15 | class ShadowMap;
16 | 
17 | class LitMaterial : public IMaterial
18 | {
19 | public:
20 | 	LitMaterial();
21 | 
22 | 	void bind() const override;
23 | 	uint32_t getId() const override;
24 | 	ResourceRef<Shader> getShader() const override;
25 | 	uint32_t getShaderId() const override;
26 | 
27 | 	glm::vec4 baseColor;
28 | 	glm::vec2 tiling;
29 | 	glm::vec2 offset;
30 | 	float roughness;
31 | 	float metallic;
32 | 	float normalMapIntensity;
33 | 	bool emission;
34 | 	float emissionIntensity;
35 | 	glm::vec3 emissionColor;
36 | 	float heightMapScale;
37 | 
38 | 	ResourceRef<Texture> albedoMap;
39 | 	ResourceRef<Texture> roughnessMap;
40 | 	ResourceRef<Texture> metallicMap;
41 | 	ResourceRef<Texture> normalMap;
42 | 	ResourceRef<Texture> occlusionMap;
43 | 	ResourceRef<Texture> emissiveMap;
44 | 	ResourceRef<Texture> heightMap;
45 | 
46 | 	void syncStaticUniforms() const;
47 | 	void syncLightUniforms() const;
48 | 	void setSampleDirectionalLight() const;
49 | 
50 | public:
51 | 	// Instance counter
52 | 	static uint32_t instances;
53 | 
54 | 	// Needed to be set before binding lit material
55 | 	// Replace this through some state object and add a function to push a state
56 | 	// Eg "RenderState" and pushRenderState(state)
57 | 	// Or rewrite matertial system for more modular and dynamic approach
58 | 	static Viewport* viewport;
59 | 	static TransformComponent* cameraTransform;
60 | 	static uint32_t ssaoInput;
61 | 	static PostProcessing::Profile* profile;
62 | 	static bool castShadows;
63 | 	static ShadowDisk* mainShadowDisk; // tmp until global shadow system
64 | 	static ShadowMap* mainShadowMap; // tmp until global shadow system
65 | 
66 | private:
67 | 	enum TextureUnits
68 | 	{
69 | 		ALBEDO_UNIT,
70 | 		NORMAL_UNIT,
71 | 		ROUGHNESS_UNIT,
72 | 		METALLIC_UNIT,
73 | 		OCCLUSION_UNIT,
74 | 		EMISSIVE_UNIT,
75 | 		HEIGHT_UNIT,
76 | 		SHADOW_DISK_UNIT,
77 | 		SHADOW_MAP_UNIT,
78 | 		SSAO_UNIT
79 | 	};
80 | 
81 | 	uint32_t id;
82 | 	ResourceRef<Shader> shader;
83 | 	uint32_t shaderId;
84 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/material/unlit/unlit_material.cpp:
--------------------------------------------------------------------------------
 1 | #include "unlit_material.h"
 2 | 
 3 | #include <utils/console.h>
 4 | #include <rendering/texture/texture.h>
 5 | #include <rendering/shader/shader_pool.h>
 6 | 
 7 | /* !!!!!!!!!!!!!!!!!!!!!!!!!!
 8 |    !!					   !!
 9 |    !! BAD TEMPORARY CODE!  !!
10 |    !!					   !!
11 |    !!!!!!!!!!!!!!!!!!!!!!!!!! */
12 | 
13 | UnlitMaterial::UnlitMaterial() : baseColor(1.0f, 1.0f, 1.0f, 1.0f),
14 | tiling(1.0f, 1.0f),
15 | offset(0.0f, 0.0f),
16 | id(0),
17 | shader(ShaderPool::get("unlit")),
18 | shaderId(0)
19 | {
20 | 	shaderId = shader->backendId();
21 | }
22 | 
23 | void UnlitMaterial::bind() const
24 | {
25 | 	if (!shader) return;
26 | 
27 | 	shader->bind();
28 | 
29 | 	shader->setVec4("baseColor", baseColor);
30 | 
31 | 	shader->setVec2("tiling", tiling);
32 | 	shader->setVec2("offset", offset);
33 | }
34 | 
35 | uint32_t UnlitMaterial::getId() const
36 | {
37 | 	return id;
38 | }
39 | 
40 | ResourceRef<Shader> UnlitMaterial::getShader() const
41 | {
42 | 	return shader;
43 | }
44 | 
45 | uint32_t UnlitMaterial::getShaderId() const
46 | {
47 | 	return shaderId;
48 | }
49 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/material/unlit/unlit_material.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../imaterial.h"
 4 | 
 5 | #include <viewport/viewport.h>
 6 | #include <memory/resource_manager.h>
 7 | 
 8 | /* !!!!!!!!!!!!!!!!!!!!!!!!!!
 9 |    !!					   !!
10 |    !! BAD TEMPORARY CODE!  !!
11 |    !!					   !!
12 |    !!!!!!!!!!!!!!!!!!!!!!!!!! */
13 | 
14 | class UnlitMaterial : public IMaterial
15 | {
16 | public:
17 | 	UnlitMaterial();
18 | 
19 | 	void bind() const override;
20 | 	uint32_t getId() const override;
21 | 	ResourceRef<Shader> getShader() const override;
22 | 	uint32_t getShaderId() const override;
23 | 
24 | 	glm::vec4 baseColor;
25 | 	glm::vec2 tiling;
26 | 	glm::vec2 offset;
27 | 
28 | private:
29 | 	uint32_t id;
30 | 	ResourceRef<Shader> shader;
31 | 	uint32_t shaderId;
32 | };
33 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/model/mesh.cpp:
--------------------------------------------------------------------------------
 1 | #include "mesh.h"
 2 | 
 3 | Mesh::Mesh() : _vao(0),
 4 | _vbo(0),
 5 | _ebo(0),
 6 | _nVertices(0),
 7 | _nIndices(0),
 8 | _materialIndex(0)
 9 | {
10 | }
11 | 
12 | void Mesh::setData(uint32_t _vao, uint32_t _vbo, uint32_t _ebo, uint32_t _nVertices, uint32_t _nIndices, uint32_t _materialIndex)
13 | {
14 | 	this->_vao = _vao;
15 | 	this->_vbo = _vbo;
16 | 	this->_ebo = _ebo;
17 | 	this->_nVertices = _nVertices;
18 | 	this->_nIndices = _nIndices;
19 | 	this->_materialIndex = _materialIndex;
20 | }
21 | 
22 | uint32_t Mesh::vao() const
23 | {
24 | 	return _vao;
25 | }
26 | 
27 | uint32_t Mesh::vbo() const
28 | {
29 | 	return _vbo;
30 | }
31 | 
32 | uint32_t Mesh::ebo() const
33 | {
34 | 	return _ebo;
35 | }
36 | 
37 | uint32_t Mesh::verticeCount() const
38 | {
39 | 	return _nVertices;
40 | }
41 | 
42 | uint32_t Mesh::indiceCount() const
43 | {
44 | 	return _nIndices;
45 | }
46 | 
47 | uint32_t Mesh::materialIndex() const
48 | {
49 | 	return _materialIndex;
50 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/model/mesh.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | class Mesh
 8 | {
 9 | public:
10 | 	Mesh();
11 | 
12 | 	// Sets the meshes existing backend buffers and metrics
13 | 	void setData(uint32_t vao, uint32_t vbo, uint32_t ebo, uint32_t nVertices, uint32_t nIndices, uint32_t materialIndex);
14 | 	
15 | 	// Returns the meshes vertex array object
16 | 	uint32_t vao() const;
17 | 
18 | 	// Returns the meshes vertex buffer object
19 | 	uint32_t vbo() const;
20 | 
21 | 	// Return the meshes element buffer object
22 | 	uint32_t ebo() const;
23 | 
24 | 	// Returns the meshes amount of vertices
25 | 	uint32_t verticeCount() const;
26 | 
27 | 	// Returns the meshes amount of indices
28 | 	uint32_t indiceCount() const;
29 | 
30 | 	// Returns the meshes material index related to the parent model
31 | 	uint32_t materialIndex() const;
32 | 
33 | private:
34 | 	uint32_t _vao;
35 | 	uint32_t _vbo;
36 | 	uint32_t _ebo;
37 | 
38 | 	uint32_t _nVertices;
39 | 	uint32_t _nIndices;
40 | 	uint32_t _materialIndex;
41 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/passes/forward_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <viewport/viewport.h>
 8 | #include <ecs/ecs_collection.h>
 9 | #include <rendering/gizmos/imgizmo.h>
10 | 
11 | class Skybox;
12 | 
13 | class ForwardPass
14 | {
15 | public:
16 | 	explicit ForwardPass(const Viewport& viewport);
17 | 
18 | 	void create(const uint32_t msaaSamples); // Creates forward pass
19 | 	void destroy(); // Destroys forward pass
20 | 
21 | 	// Forward passes all entity render targets and returns color output
22 | 	uint32_t render(const glm::mat4& view, const glm::mat4& projection, const glm::mat4& viewProjection);
23 | 
24 | 	uint32_t getDepthOutput(); // Returns depth output
25 | 
26 | 	void linkSkybox(Skybox* source);
27 | 	bool drawSkybox;
28 | 
29 | 	void linkGizmos(IMGizmo* gizmos);
30 | 	bool drawGizmos;
31 | 
32 | 	void setClearColor(glm::vec4 clearColor); // Clear color for forward pass
33 | private:
34 | 	const Viewport& viewport; // Viewport forward pass instance is linked to
35 | 
36 | 	Skybox* skybox; // Skybox that will be rendered during forward pass (optional)
37 | 	IMGizmo* gizmos; // Gizmo instance that will be rendered during forward pass (optional)
38 | 	
39 | 	glm::vec4 clearColor; // Clear color for forward pass
40 | 
41 | 	uint32_t outputFbo;	 // Output framebuffer
42 | 	uint32_t outputColor; // Output texture
43 | 	uint32_t outputDepth; // Output texture
44 | 
45 | 	uint32_t multisampledFbo;		 // Anti-aliasing framebuffer
46 | 	uint32_t multisampledRbo;		 // Anti-aliasing renderbuffer
47 | 	uint32_t multisampledColorBuffer; // Anti-aliasing color buffer texture
48 | 
49 | 	void renderMesh(TransformComponent& transform, MeshRendererComponent& renderer);
50 | 	void renderMeshes();
51 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/passes/pre_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <viewport/viewport.h>
 8 | #include <memory/resource_manager.h>
 9 | 
10 | class Shader;
11 | 
12 | class PrePass
13 | {
14 | public:
15 | 	explicit PrePass(const Viewport& viewport);
16 | 	
17 | 	void create();
18 | 	void destroy();
19 | 
20 | 	void render(glm::mat4 viewProjection, glm::mat3 viewNormal);
21 | 
22 | 	uint32_t getDepthOutput();
23 | 	uint32_t getNormalOutput();
24 | 
25 | private:
26 | 	const Viewport& viewport;
27 | 
28 | 	uint32_t fbo;
29 | 	uint32_t depthOutput;
30 | 	uint32_t normalOutput;
31 | 
32 | 	ResourceRef<Shader> prePassShader;
33 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/passes/ssao_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <cstdint>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <viewport/viewport.h>
 8 | #include <memory/resource_manager.h>
 9 | #include <rendering/postprocessing/post_processing.h>
10 | 
11 | class Shader;
12 | 
13 | class SSAOPass
14 | {
15 | public:
16 | 	explicit SSAOPass(Viewport& viewport);
17 | 
18 | 	void create(float aoScale = 0.5f, int32_t maxKernelSamples = 64, float noiseResolution = 4.0f);  // Create ambient occlusion pass
19 | 	void destroy(); // Destroy ambient occlusion pass
20 | 
21 | 	uint32_t render(const glm::mat4& projection, const PostProcessing::Profile& profile, uint32_t depthInput, uint32_t normalInput); // Render ambient occlusion pass and return blurred output
22 | 
23 | 	uint32_t getOutputRaw(); // Returns ao output (raw ssao texture)
24 | 	uint32_t getOutputProcessed(); // Returns blurred output (processed ssao texture)
25 | private:
26 | 	enum TextureUnits
27 | 	{
28 | 		DEPTH_UNIT,
29 | 		NORMAL_UNIT,
30 | 		NOISE_UNIT,
31 | 		AO_UNIT
32 | 	};
33 | 
34 | 	Viewport& viewport;
35 | 
36 | 	float aoScale; // Scale of ambient occlusion resolution in relation to viewport resolution
37 | 	int32_t maxKernelSamples; // Amount of kernel samples being generated (therefore the max amount to be utilised)
38 | 	float noiseResolution; // Resolution of noise texture
39 | 
40 | 	uint32_t fbo;		   // Framebuffer
41 | 	uint32_t aoOutput;	   // Ambient occlusion output
42 | 	uint32_t blurredOutput; // Blurred ambient occlusion output
43 | 
44 | 	void ambientOcclusionPass(const glm::mat4& projection, const PostProcessing::Profile& profile, uint32_t depthInput, uint32_t normalInput);
45 | 	void blurPass(const PostProcessing::Profile& profile);
46 | 
47 | 	ResourceRef<Shader> aoPassShader; // Ambient occlusion pass shader
48 | 	ResourceRef<Shader> aoBlurShader; // Composite shader
49 | 
50 | 	std::vector<glm::vec3> kernel; // Sample kernel
51 | 	uint32_t noiseTexture;	  // Noise texture
52 | 
53 | 	std::vector<glm::vec3> generateKernel(); // Generate sample kernel
54 | 	uint32_t generateNoiseTexture();		// Generate noise texture
55 | 
56 | 	float random();									// Get random
57 | 	float lerp(float start, float end, float value); // Linear interpolation
58 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/postprocessing/bloom_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <cstdint>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <viewport/viewport.h>
 8 | #include <memory/resource_manager.h>
 9 | 
10 | class Shader;
11 | 
12 | class BloomPass
13 | {
14 | public:
15 | 	explicit BloomPass(const Viewport& viewport);
16 | 
17 | 	void create(const uint32_t mipDepth);
18 | 	void destroy();
19 | 
20 | 	uint32_t render(const uint32_t hdrInput);
21 | 
22 | 	float threshold;
23 | 	float softThreshold;
24 | 	float filterRadius;
25 | 
26 | private:
27 | 	uint32_t prefilteringPass(const uint32_t hdrInput);
28 | 	void downsamplingPass(const uint32_t hdrInput);
29 | 	void upsamplingPass();
30 | 
31 | private:
32 | 	const Viewport& viewport;
33 | 
34 | 	struct Mip
35 | 	{
36 | 		glm::ivec2 iSize = glm::ivec2(0, 0);
37 | 		glm::vec2 fSize = glm::vec2(0.0f, 0.0f);
38 | 		glm::vec2 inversedSize = glm::vec2(0.0f, 0.0f);
39 | 		uint32_t texture = 0;
40 | 	};
41 | 	std::vector<Mip> mipChain;
42 | 
43 | 	glm::ivec2 iViewportSize;
44 | 	glm::vec2 fViewportSize;
45 | 	glm::vec2 inversedViewportSize;
46 | 
47 | 	uint32_t framebuffer;
48 | 	uint32_t prefilterOutput;
49 | 
50 | 	ResourceRef<Shader> prefilterShader;
51 | 	ResourceRef<Shader> downsamplingShader;
52 | 	ResourceRef<Shader> upsamplingShader;
53 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/postprocessing/motion_blur_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include <viewport/viewport.h>
 7 | #include <memory/resource_manager.h>
 8 | #include <rendering/postprocessing/post_processing.h>
 9 | 
10 | class Shader;
11 | 
12 | class MotionBlurPass
13 | {
14 | public:
15 | 	explicit MotionBlurPass(const Viewport& viewport);
16 | 
17 | 	void create();
18 | 	void destroy();
19 | 
20 | 	uint32_t render(const glm::mat4& view, const glm::mat4& projection, const glm::mat4& viewProjection, const PostProcessing::Profile& profile, const uint32_t hdrInput, const uint32_t depthInput, const uint32_t velocityBufferInput);
21 | 
22 | private:
23 | 	enum TextureUnits
24 | 	{
25 | 		HDR_UNIT,
26 | 		DEPTH_UNIT,
27 | 		VELOCITY_UNIT
28 | 	};
29 | 
30 | 	const Viewport& viewport;
31 | 
32 | 	uint32_t fbo;
33 | 	uint32_t output;
34 | 
35 | 	ResourceRef<Shader> shader;
36 | 
37 | 	glm::mat4 previousViewProjectionMatrix;
38 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/postprocessing/post_processing.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include <rendering/texture/texture.h>
 7 | 
 8 | namespace PostProcessing
 9 | {
10 | 
11 | 	struct Color {
12 | 
13 | 		float exposure = 1.0f;
14 | 		float contrast = 1.004f;
15 | 		float gamma = 2.2f;
16 | 
17 | 	};
18 | 
19 | 	struct MotionBlur {
20 | 
21 | 		bool enabled = true;
22 | 
23 | 		bool cameraEnabled = true;
24 | 		float cameraIntensity = 0.8f;
25 | 		int32_t cameraSamples = 32;
26 | 
27 | 		bool objectEnabled = false;
28 | 		int32_t objectSamples = 16;
29 | 
30 | 	};
31 | 
32 | 	struct Bloom {
33 | 
34 | 		bool enabled = true;
35 | 		float intensity = 0.075f;
36 | 		glm::vec3 color = glm::vec3(1.0f);
37 | 		float threshold = 0.465f;
38 | 		float softThreshold = 0.0f;
39 | 		float filterRadius = 0.0f;
40 | 
41 | 		bool lensDirtEnabled = false;
42 | 		uint32_t lensDirtTexture = 0;
43 | 		float lensDirtIntensity = 0.0f;
44 | 
45 | 	};
46 | 
47 | 	struct ChromaticAberration {
48 | 
49 | 		bool enabled = true;
50 | 		float intensity = -0.155f;
51 | 		int32_t iterations = 12;
52 | 
53 | 	};
54 | 
55 | 	struct Vignette {
56 | 
57 | 		bool enabled = true;
58 | 		float intensity = 1.0f;
59 | 		glm::vec3 color = glm::vec3(0.0f);
60 | 		float radius = 0.74f;
61 | 		float softness = 0.42f;
62 | 		float roundness = 1.8f;
63 | 
64 | 	};
65 | 
66 | 	struct AmbientOcclusion {
67 | 
68 | 		bool enabled = false;
69 | 		float radius = 0.2f;
70 | 		int32_t samples = 64;
71 | 		float power = 20.0f;
72 | 		float bias = 0.03f;
73 | 
74 | 	};
75 | 
76 | 	struct Profile {
77 | 
78 | 		Color color;
79 | 		MotionBlur motionBlur;
80 | 		Bloom bloom;
81 | 		ChromaticAberration chromaticAberration;
82 | 		Vignette vignette;
83 | 		AmbientOcclusion ambientOcclusion;
84 | 
85 | 	};
86 | 
87 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/postprocessing/post_processing_pipeline.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | #include <viewport/viewport.h>
 6 | #include <memory/resource_manager.h>
 7 | #include <rendering/texture/texture.h>
 8 | #include <rendering/postprocessing/bloom_pass.h>
 9 | #include <rendering/postprocessing/post_processing.h>
10 | #include <rendering/postprocessing/motion_blur_pass.h>
11 | 
12 | class Shader;
13 | 
14 | class PostProcessingPipeline
15 | {
16 | public:
17 | 	explicit PostProcessingPipeline(const Viewport& viewport, bool renderToScreen);
18 | 
19 | 	void create();	// Create post processing pipeline
20 | 	void destroy(); // Destroy post processing pipeline
21 | 
22 | 	void render(const glm::mat4& view, const glm::mat4& projection, const glm::mat4& viewProjection, const PostProcessing::Profile& profile, const uint32_t hdrInput, const uint32_t depthInput, const uint32_t velocityBufferInput); // Render post processing by performing all post processing passes on input
23 | 
24 | 	uint32_t getOutput(); // Get output of last post processing render
25 | 
26 | private:
27 | 	static constexpr int32_t DEFAULT_BLOOM_MIP_DEPTH = 16;
28 | 
29 | 	enum TextureUnits
30 | 	{
31 | 		HDR_UNIT,
32 | 		DEPTH_UNIT,
33 | 		BLOOM_UNIT,
34 | 		LENS_DIRT_UNIT
35 | 	};
36 | 
37 | 	const Viewport& viewport;
38 | 
39 | 	const bool renderToScreen;
40 | 
41 | 	void syncConfiguration(const PostProcessing::Profile& profile); // Sync the post processing configuration with final pass shader
42 | 
43 | 	uint32_t fbo;	 // Framebuffer
44 | 	uint32_t output; // Post processing output
45 | 
46 | 	ResourceRef<Shader> finalPassShader; // Post processing final pass shader
47 | 
48 | private:
49 | 	MotionBlurPass motionBlurPass;
50 | 	BloomPass bloomPass;
51 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/primitives/global_quad.cpp:
--------------------------------------------------------------------------------
 1 | #include "global_quad.h"
 2 | 
 3 | #include <glad/glad.h>
 4 | 
 5 | namespace GlobalQuad {
 6 | 
 7 | 	uint32_t _vbo = 0;
 8 | 	uint32_t _vao = 0;
 9 | 
10 | 	void create()
11 | 	{
12 | 		float vertices[] =
13 | 		{
14 | 			1.0f, -1.0f, 1.0f, 0.0f,
15 | 			-1.0f, -1.0f, 0.0f, 0.0f,
16 | 			-1.0f, 1.0f, 0.0f, 1.0f,
17 | 
18 | 			1.0f, 1.0f, 1.0f, 1.0f,
19 | 			1.0f, -1.0f, 1.0f, 0.0f,
20 | 			-1.0f, 1.0f, 0.0f, 1.0f };
21 | 
22 | 		glGenVertexArrays(1, &_vao);
23 | 		glGenBuffers(1, &_vbo);
24 | 
25 | 		glBindVertexArray(_vao);
26 | 		glBindBuffer(GL_ARRAY_BUFFER, _vbo);
27 | 
28 | 		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);
29 | 		glEnableVertexAttribArray(0);
30 | 		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0);
31 | 		glEnableVertexAttribArray(1);
32 | 		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float)));
33 | 	}
34 | 
35 | 	void bind()
36 | 	{
37 | 		glBindVertexArray(_vao);
38 | 	}
39 | 
40 | 	void render()
41 | 	{
42 | 		glDrawArrays(GL_TRIANGLES, 0, 6);
43 | 	}
44 | 
45 | 	const uint32_t vbo()
46 | 	{
47 | 		return _vbo;
48 | 	}
49 | 
50 | 	const uint32_t vao()
51 | 	{
52 | 		return _vao;
53 | 	}
54 | 
55 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/primitives/global_quad.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | namespace GlobalQuad
 6 | {
 7 | 
 8 | 	void create();
 9 | 	void bind();
10 | 	void render();
11 | 
12 | 	const uint32_t vbo();
13 | 	const uint32_t vao();
14 | 
15 | };
16 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/primitives/shapes.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | class Mesh;
 6 | 
 7 | namespace Shapes {
 8 | 
 9 | 	// Creates a static plane mesh synchronously
10 | 	Mesh* createPlane();
11 | 
12 | 	// Creates a static cube mesh synchronously
13 | 	Mesh* createCube();
14 | 
15 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/shader/shader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <cstdint>
 5 | #include <glm/glm.hpp>
 6 | #include <unordered_map>
 7 | 
 8 | #include <utils/fsutil.h>
 9 | #include <memory/resource.h>
10 | 
11 | class Shader : public Resource
12 | {
13 | public:
14 | 	Shader();
15 | 	~Shader();
16 | 
17 | 	// Default pipe for creating shader
18 | 	ResourcePipe create() {
19 | 		return std::move(pipe()
20 | 			>> BIND_TASK(Shader, loadIoData)
21 | 			>> BIND_TASK_WITH_FLAGS(Shader, uploadBuffers, TaskFlags::UseContextThread));
22 | 	}
23 | 
24 | 	// Sets the path of the shaders source
25 | 	void setSource(const FS::Path& sourcePath);
26 | 
27 | 	// Binds the shader program
28 | 	void bind() const;
29 | 
30 | 	// Returns the shader programs backend id
31 | 	uint32_t backendId() const;
32 | 
33 | 	void setBool(const std::string& identifier, bool value);
34 | 	void setInt(const std::string& identifier, int32_t value);
35 | 	void setFloat(const std::string& identifier, float value);
36 | 	void setVec2(const std::string& identifier, glm::vec2 value);
37 | 	void setVec3(const std::string& identifier, glm::vec3 value);
38 | 	void setVec4(const std::string& identifier, glm::vec4 value);
39 | 	void setMatrix3(const std::string& identifier, glm::mat3 value);
40 | 	void setMatrix4(const std::string& identifier, glm::mat4 value);
41 | 
42 | private:
43 | 	struct Data {
44 | 		std::string vertexSource;
45 | 		std::string fragmentSource;
46 | 	};
47 | 
48 | 	// Path of shader source
49 | 	FS::Path sourcePath;
50 | 
51 | 	// Shader source data
52 | 	Data data;
53 | 
54 | 	// Shader program uniform location cache
55 | 	std::unordered_map<std::string, int32_t> uniforms;
56 | 
57 | 	// Shader program backend id
58 | 	uint32_t _backendId;
59 | 
60 | private:
61 | 	int32_t getUniformLocation(const std::string& identifier);
62 | 
63 | 	bool shaderCompiled(const char* type, int32_t shader);
64 | 	bool programLinked(int32_t program);
65 | 
66 | 	bool loadIoData();
67 | 	void freeIoData();
68 | 	bool uploadBuffers();
69 | 	void deleteBuffers();
70 | };
71 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/shader/shader_pool.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include "shader_pool.h"
 3 | 
 4 | #include <thread>
 5 | #include <chrono>
 6 | #include <unordered_map>
 7 | 
 8 | #include <utils/console.h>
 9 | #include <rendering/shader/shader.h>
10 | #include <context/application_context.h>
11 | 
12 | namespace ShaderPool {
13 | 
14 | 	ResourceRef<Shader> gEmpty = std::make_shared<Shader>();
15 | 	std::unordered_map<std::string, ResourceRef<Shader>> gShaders;
16 | 
17 | 	void _loadAll(const FS::Path& directory, bool async)
18 | 	{
19 | 		ResourceManager& resource = ApplicationContext::resourceManager();
20 | 
21 | 		std::vector<FS::Path> shaderPaths;
22 | 		std::vector<std::string> shaderNames;
23 | 
24 | 		std::vector<FS::Path> shadersInFolder = FS::getFolders(directory);
25 | 		for (int32_t i = 0; i < shadersInFolder.size(); i++)
26 | 		{
27 | 			const FS::Path& shaderPath = shadersInFolder[i];
28 | 			shaderPaths.push_back(shaderPath);
29 | 			shaderNames.push_back(shaderPath.filename().string());
30 | 		}
31 | 
32 | 		for (int32_t i = 0; i < shaderPaths.size(); i++)
33 | 		{
34 | 			// Get shaders identifier
35 | 			std::string identifier = shaderNames[i];
36 | 
37 | 			// Skip shader creation if it already exists
38 | 			if (gShaders.find(identifier) != gShaders.end()) continue;
39 | 
40 | 			// Create new shader and set its source
41 | 			auto [shaderId, shader] = resource.create<Shader>(identifier + "_shader");
42 | 			shader->setSource(shaderPaths[i]);
43 | 
44 | 			// Load shader
45 | 			if (async) {
46 | 				resource.exec(shader->create());
47 | 			}
48 | 			else {
49 | 				resource.execAsDependency(shader->create());
50 | 			}
51 | 			gShaders[identifier] = shader;
52 | 		}
53 | 	}
54 | 
55 | 	void loadAllSync(const FS::Path& directory)
56 | 	{
57 | 		Console::out::info("Shader Pool", "Loading shaders from '" + directory.string() + "'");
58 | 		_loadAll(directory, false);
59 | 	}
60 | 
61 | 	void loadAllAsync(const FS::Path& directory)
62 | 	{
63 | 		Console::out::info("Shader Pool", "Queued loading shader in '" + directory.string() + "'");
64 | 		_loadAll(directory, true);
65 | 	}
66 | 
67 | 	ResourceRef<Shader> empty()
68 | 	{
69 | 		return gEmpty;
70 | 	}
71 | 
72 | 	ResourceRef<Shader> get(const std::string& identifier)
73 | 	{
74 | 		if (auto it = gShaders.find(identifier); it != gShaders.end()) {
75 | 			// Shader available, return shader
76 | 			return it->second;
77 | 		}
78 | 		else {
79 | 			// Shader not found, return empty shader
80 | 			Console::out::warning("Shader Pool", "Shader '" + identifier + "' was requested but does not exist!");
81 | 			return gEmpty;
82 | 		}
83 | 	}
84 | 
85 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/shader/shader_pool.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | 
 6 | #include <utils/fsutil.h>
 7 | #include <memory/resource_manager.h>
 8 | 
 9 | class Shader;
10 | 
11 | namespace ShaderPool
12 | {
13 | 	// Loads all shaders from the given directory synchronously
14 | 	void loadAllSync(const FS::Path& directory);
15 | 
16 | 	// Loads all shaders from the given directory asynchronously
17 | 	void loadAllAsync(const FS::Path& directory);
18 | 
19 | 	// Returns the global empty default shader
20 | 	ResourceRef<Shader> empty();
21 | 
22 | 	// Returns a loaded shader by the given identifier
23 | 	ResourceRef<Shader> get(const std::string& identifier);
24 | };
25 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/shadows/shadow_disk.cpp:
--------------------------------------------------------------------------------
 1 | #include "shadow_disk.h"
 2 | 
 3 | #include <vector>
 4 | #include <random>
 5 | #include <glad/glad.h>
 6 | 
 7 | #include <utils/console.h>
 8 | 
 9 | #define M_PI 3.14159265358979323846
10 | 
11 | ShadowDisk::ShadowDisk(uint32_t windowSize, uint32_t filterSize, uint32_t radius) : texture(0),
12 | windowSize(windowSize),
13 | filterSize(filterSize),
14 | radius(radius)
15 | {
16 | 	// Create data buffer
17 | 	std::vector<float> data;
18 | 
19 | 	// Generate sample disk texture data with random samples
20 | 	int32_t bufferSize = windowSize * windowSize * filterSize * filterSize * 2;
21 | 	data.resize(bufferSize);
22 | 	size_t index = 0;
23 | 	for (int32_t texY = 0; texY < windowSize; texY++)
24 | 	{
25 | 		for (int32_t texX = 0; texX < windowSize; texX++)
26 | 		{
27 | 			for (int32_t v = filterSize - 1; v >= 0; v--)
28 | 			{
29 | 				for (int32_t u = 0; u < filterSize; u++)
30 | 				{
31 | 					float x = ((float)u + 0.5f + random()) / (float)filterSize;
32 | 					float y = ((float)v + 0.5f + random()) / (float)filterSize;
33 | 
34 | 					data[index] = sqrtf(y) * cosf(2 * M_PI * x);
35 | 					data[index + 1] = sqrtf(y) * sinf(2 * M_PI * x);
36 | 					index += 2;
37 | 				}
38 | 			}
39 | 		}
40 | 	}
41 | 
42 | 	// Generate 3D sample disk texture
43 | 	int32_t nFilterSamples = filterSize * filterSize;
44 | 
45 | 	// Generate texture
46 | 	glGenTextures(1, &texture);
47 | 	glBindTexture(GL_TEXTURE_3D, texture);
48 | 	glTexStorage3D(GL_TEXTURE_3D, 1, GL_RGBA32F, nFilterSamples / 2, windowSize, windowSize);
49 | 	glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, nFilterSamples / 2, windowSize, windowSize, GL_RGBA, GL_FLOAT, &data[0]);
50 | 
51 | 	// Set texture parameters
52 | 	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
53 | 	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
54 | 
55 | 	// Unbind texture
56 | 	glBindTexture(GL_TEXTURE_3D, 0);
57 | }
58 | 
59 | void ShadowDisk::bind(uint32_t unit)
60 | {
61 | 	// Bind shadow disk texture to given unit
62 | 	glActiveTexture(GL_TEXTURE0 + unit);
63 | 	glBindTexture(GL_TEXTURE_3D, texture);
64 | }
65 | 
66 | uint32_t ShadowDisk::getWindowSize()
67 | {
68 | 	return windowSize;
69 | }
70 | 
71 | uint32_t ShadowDisk::getFilterSize()
72 | {
73 | 	return filterSize;
74 | }
75 | 
76 | uint32_t ShadowDisk::getRadius()
77 | {
78 | 	return radius;
79 | }
80 | 
81 | float ShadowDisk::random()
82 | {
83 | 	static std::default_random_engine generator;
84 | 	// static std::mt19937 generator(std::random_device{}()); // Generator alternative
85 | 	static std::uniform_real_distribution<float> distribution(-0.5f, 0.5f);
86 | 	return distribution(generator);
87 | }
88 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/shadows/shadow_disk.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | class ShadowDisk
 6 | {
 7 | public:
 8 | 	explicit ShadowDisk(uint32_t windowSize, uint32_t filterSize, uint32_t radius);
 9 | 	void bind(uint32_t unit);
10 | 
11 | 	uint32_t getWindowSize();
12 | 	uint32_t getFilterSize();
13 | 	uint32_t getRadius();
14 | 
15 | private:
16 | 	float random();
17 | 
18 | 	uint32_t texture;
19 | 
20 | 	uint32_t windowSize;
21 | 	uint32_t filterSize;
22 | 	uint32_t radius;
23 | };
24 | 


--------------------------------------------------------------------------------
/nuro-core/rendering/shadows/shadow_map.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <ecs/ecs_collection.h>
 8 | #include <rendering/shader/shader.h>
 9 | #include <memory/resource_manager.h>
10 | 
11 | class ShadowMap
12 | {
13 | public:
14 | 	explicit ShadowMap(uint32_t resolutionWidth, uint32_t resolutionHeight);
15 | 
16 | 	// Create the shadow map
17 | 	void create();
18 | 
19 | 	// Destroy the shadow map
20 | 	void destroy();
21 | 
22 | 	// Renders the shadow map for a directional light source
23 | 	void castShadows(DirectionalLightComponent& directionalLight, TransformComponent& transform, float boundsWidth, float boundsHeight, float near, float far);
24 | 
25 | 	// Renders the shadow map for a spotlight source
26 | 	void castShadows(SpotlightComponent& spotlight, TransformComponent& transform);
27 | 
28 | 	// Bind the shadow map texture to a given unit
29 | 	void bind(uint32_t unit);
30 | 
31 | 	// Returns the texture of the shadow map
32 | 	uint32_t getTexture() const;
33 | 
34 | 	// Returns the resolution width of the shadow map
35 | 	uint32_t getResolutionWidth() const;
36 | 
37 | 	// Returns the resolution height of the shadow map
38 | 	uint32_t getResolutionHeight() const;
39 | 
40 | 	// Returns the framebuffer of the shadow map
41 | 	uint32_t getFramebuffer() const;
42 | 
43 | 	// Returns the light space matrix of the shadow map
44 | 	const glm::mat4& getLightSpace() const;
45 | 
46 | 	// Saves the latest render of the shadow map as an image
47 | 	bool saveAsImage(int32_t width, int32_t height, const std::string& filename);
48 | 
49 | private:
50 | 	// Render onto singular texture
51 | 	void renderSingular(glm::mat4 view, glm::mat4 projection);
52 | 
53 | 	// Returns a view matrix for a light
54 | 	glm::mat4 getView(const glm::vec3& lightPosition, const glm::vec3& lightDirection) const;
55 | 
56 | 	// Returns an orthograpghic projection matrix for a light
57 | 	glm::mat4 getProjectionOrthographic(float boundsWidth, float boundsHeight, float near, float far) const;
58 | 
59 | 	// Returns a perspective projection matrix for a light
60 | 	glm::mat4 getProjectionPerspective(float fov, float aspect, float near, float far) const;
61 | 
62 | 	// Shadow map resolution width
63 | 	uint32_t resolutionWidth;
64 | 
65 | 	// Shadow map resolution height
66 | 	uint32_t resolutionHeight;
67 | 
68 | 	// Shadow map backend texture id
69 | 	uint32_t texture;
70 | 
71 | 	// Shadow map backend framebuffer id
72 | 	uint32_t framebuffer;
73 | 
74 | 	// Cache for latest light space matrix
75 | 	glm::mat4 lightSpace;
76 | 
77 | 	// Shadow pass shader
78 | 	ResourceRef<Shader> shadowPassShader;
79 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/skybox/cubemap.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | #include <cstdint>
 6 | 
 7 | #include <utils/fsutil.h>
 8 | #include <memory/resource.h>
 9 | 
10 | class Cubemap : public Resource
11 | {
12 | public:
13 | 	Cubemap();
14 | 	~Cubemap() override;
15 | 
16 | 	// Default pipe for creating cubemap
17 | 	ResourcePipe create() {
18 | 		return std::move(pipe()
19 | 			>> BIND_TASK(Cubemap, loadIoData)
20 | 			>> BIND_TASK_WITH_FLAGS(Cubemap, uploadBuffers, TaskFlags::UseContextThread));
21 | 	}
22 | 
23 | 	// Sets cubemaps source to be cross layout
24 | 	void setSource_Cross(const FS::Path& sourcePath);
25 | 
26 | 	// Sets cubemaps source to be multiple individual faces
27 | 	void setSource_Individual(const FS::Path& rightPath, const FS::Path& leftPath, const FS::Path& topPath, const FS::Path& bottomPath, const FS::Path& frontPath, const FS::Path& backPath);
28 | 
29 | 	// Returns the backend id of the cubemap texture
30 | 	uint32_t backendId() const;
31 | 
32 | private:
33 | 	struct Source {
34 | 		enum class Type {
35 | 			CROSS,
36 | 			INDIVIDUAL
37 | 		};
38 | 
39 | 		// Type of the cubemap source
40 | 		Type type = Type::CROSS;
41 | 
42 | 		// All image source paths associated with the cubemap
43 | 		std::vector<FS::Path> paths;
44 | 	};
45 | 
46 | 	struct FaceData
47 | 	{
48 | 		std::vector<unsigned char> data;
49 | 		int32_t width = 0;
50 | 		int32_t height = 0;
51 | 		int32_t channels = 0;
52 | 	};
53 | 
54 | 	struct ImageData
55 | 	{
56 | 		unsigned char* data;
57 | 		int32_t width;
58 | 		int32_t height;
59 | 		int32_t channels;
60 | 
61 | 		ImageData() :
62 | 			data(nullptr),
63 | 			width(0),
64 | 			height(0),
65 | 			channels(0)
66 | 		{};
67 | 
68 | 		ImageData(unsigned char* data, uint32_t width, uint32_t height, uint32_t channels) :
69 | 			data(data),
70 | 			width(width),
71 | 			height(height),
72 | 			channels(channels)
73 | 		{};
74 | 	};
75 | 
76 | private:
77 | 	// Loads a cubemap by multiple faces in one file
78 | 	void loadCrossCubemap(const FS::Path& sourcePath);
79 | 
80 | 	// Loads an individual face for a cubemap
81 | 	void loadIndividualFace(const FS::Path& sourcePath);
82 | 
83 | 	bool loadIoData();
84 | 	void freeIoData();
85 | 	bool uploadBuffers();
86 | 	void deleteBuffers();
87 | 
88 | 	// Cubemap source
89 | 	Source source;
90 | 
91 | 	// Cubemap data
92 | 	std::vector<FaceData> data;
93 | 
94 | 	// Backend id of cubemap texture
95 | 	uint32_t _backendId;
96 | 
97 | 	// Loads given images data
98 | 	ImageData loadImageData(const FS::Path& sourcePath);
99 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/skybox/skybox.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <string>
 5 | #include <vector>
 6 | #include <glm/glm.hpp>
 7 | 
 8 | #include <memory/resource_manager.h>
 9 | #include <rendering/skybox/cubemap.h>
10 | 
11 | class Shader;
12 | 
13 | class Skybox
14 | {
15 | public:
16 | 	Skybox();
17 | 
18 | 	// Sets the cubemap of the skybox
19 | 	void setCubemap(ResourceRef<Cubemap> cubemap);
20 | 
21 | 	// Returns the cubemap of the skybox
22 | 	ResourceRef<Cubemap> getCubemap() const;
23 | 
24 | 	// Sets the emission of the skybox
25 | 	void setEmission(float emission);
26 | 
27 | 	// Returns the current emission of the skybox
28 | 	float getEmission() const;
29 | 
30 | 	// Generates the skybox
31 | 	void create();
32 | 
33 | 	// Renders the skybox with the given transformation matrices
34 | 	void render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
35 | 
36 | private:
37 | 	ResourceRef<Cubemap> cubemap;
38 | 	ResourceRef<Shader> shader;
39 | 	uint32_t vao;
40 | 	uint32_t vbo;
41 | 	float emission;
42 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/texture/texture.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <cstdint>
 5 | 
 6 | #include <utils/fsutil.h>
 7 | #include <memory/resource.h>
 8 | 
 9 | enum class TextureType
10 | {
11 | 	EMPTY,
12 | 	IMAGE,
13 | 
14 | 	ALBEDO,
15 | 	ROUGHNESS,
16 | 	METALLIC,
17 | 	NORMAL,
18 | 	OCCLUSION,
19 | 	EMISSIVE,
20 | 	HEIGHT,
21 | };
22 | 
23 | class Texture : public Resource
24 | {
25 | public:
26 | 	Texture();
27 | 	~Texture() override;
28 | 
29 | 	// Default pipe for creating texture
30 | 	ResourcePipe create() {
31 | 		return std::move(pipe()
32 | 			>> BIND_TASK(Texture, loadIoData)
33 | 			>> BIND_TASK_WITH_FLAGS(Texture, uploadBuffers, TaskFlags::UseContextThread)
34 | 		);
35 | 	}
36 | 
37 | 	// Sets the textures type and path of texture source
38 | 	void setSource(TextureType type, const FS::Path& sourcePath);
39 | 
40 | 	// Returns the textures backend id
41 | 	uint32_t backendId() const;
42 | 
43 | 	// Sets the given texture backend id to be the default backend id for new textures
44 | 	static void setDefaultTexture(uint32_t textureId);
45 | 
46 | private:
47 | 	bool loadIoData();
48 | 	void freeIoData();
49 | 	bool uploadBuffers();
50 | 	void deleteBuffers();
51 | 
52 | 	// Default texture fallback
53 | 	static uint32_t defaultTextureId;
54 | 
55 | 	// Texture type
56 | 	TextureType type;
57 | 
58 | 	// Path of texture source
59 | 	FS::Path sourcePath;
60 | 
61 | 	// Dynamic temporary texture data
62 | 	unsigned char* data;
63 | 
64 | 	uint32_t width;
65 | 	uint32_t height;
66 | 	uint32_t channels;
67 | 
68 | 	// Backend id of texture
69 | 	uint32_t _backendId;
70 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/transformation/transformation.cpp:
--------------------------------------------------------------------------------
 1 | #include "transformation.h"
 2 | 
 3 | #include <glm/glm.hpp>
 4 | #include <glm/gtc/quaternion.hpp>
 5 | #include <glm/gtc/matrix_transform.hpp>
 6 | 
 7 | namespace Transformation {
 8 | 
 9 | 	glm::vec3 swap(const glm::vec3& position)
10 | 	{
11 | 		return glm::vec3(position.x, position.y, -position.z);
12 | 	}
13 | 
14 | 	glm::quat swap(const glm::quat& rotation)
15 | 	{
16 | 		return glm::quat(rotation.w, -rotation.x, -rotation.y, rotation.z);
17 | 	}
18 | 
19 | 	glm::mat4 model(const glm::vec3& position, const glm::quat& rotation, const glm::vec3& scale)
20 | 	{
21 | 		glm::mat4 model(1.0f);
22 | 
23 | 		model = glm::translate(model, swap(position));
24 | 		model *= glm::mat4_cast(glm::normalize(swap(rotation)));
25 | 		model = glm::scale(model, scale);
26 | 
27 | 		return model;
28 | 	}
29 | 
30 | 	glm::mat4 view(const glm::vec3& cameraPosition, const glm::quat& cameraRotation)
31 | 	{
32 | 		glm::vec3 position = swap(cameraPosition);
33 | 		glm::quat rotation = swap(cameraRotation);
34 | 
35 | 		rotation = glm::normalize(rotation);
36 | 
37 | 		glm::vec3 forward = rotation * glm::vec3(0.0f, 0.0f, -1.0f);
38 | 		glm::vec3 up = rotation * glm::vec3(0.0f, 1.0f, 0.0f);
39 | 
40 | 		return glm::lookAt(position, position + forward, up);
41 | 	}
42 | 
43 | 	glm::mat4 projection(float fov, float aspect, float near, float far)
44 | 	{
45 | 		return glm::perspective(glm::radians(fov), aspect, near, far);
46 | 	}
47 | 
48 | 	glm::mat4 normal(const glm::mat4& model)
49 | 	{
50 | 		return glm::transpose(glm::inverse(glm::mat3(model)));
51 | 	}
52 | 
53 | }


--------------------------------------------------------------------------------
/nuro-core/rendering/transformation/transformation.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | namespace Transformation
 7 | {
 8 | 	// Converts a position between backend and user coordinates
 9 | 	glm::vec3 swap(const glm::vec3& position);
10 | 
11 | 	// Converts a rotation between backend and user coordinates
12 | 	glm::quat swap(const glm::quat& rotation);
13 | 	
14 | 	// Evaluates model matrix
15 | 	glm::mat4 model(const glm::vec3& position, const glm::quat& rotation, const glm::vec3& scale);
16 | 
17 | 	// Evaluates view matrix
18 | 	glm::mat4 view(const glm::vec3& cameraPosition, const glm::quat& cameraRotation);
19 | 
20 | 	// Evaluates projection matrix
21 | 	glm::mat4 projection(float fov, float aspect, float near, float far);
22 | 
23 | 	// Evaluates normal matrix (transposed inversed model matrix) of given model matrix
24 | 	glm::mat4 normal(const glm::mat4& model);
25 | };


--------------------------------------------------------------------------------
/nuro-core/rendering/velocitybuffer/velocity_buffer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <viewport/viewport.h>
 8 | #include <memory/resource_manager.h>
 9 | #include <rendering/postprocessing/post_processing.h>
10 | 
11 | class Shader;
12 | 
13 | class VelocityBuffer
14 | {
15 | public:
16 | 	explicit VelocityBuffer(const Viewport& viewport);
17 | 
18 | 	void create();	// Setup velocity buffer
19 | 	void destroy(); // Delete velocity buffer
20 | 
21 | 	uint32_t render(const glm::mat4& view, const glm::mat4& projection, const PostProcessing::Profile& profile); // Renders the velocity buffer and returns the filtered output
22 | 
23 | private:
24 | 	uint32_t velocityPass(const glm::mat4& view, const glm::mat4& projection);	  // Performs velocity passes to render velocity buffer and returns velocity buffer
25 | 	uint32_t postfilteringPass(); // Performs postfiltering pass on rendered velocity buffer and returns postfiltered velocity buffer
26 | 
27 | private:
28 | 	const Viewport& viewport;
29 | 
30 | 	uint32_t fbo; // Framebuffer
31 | 	uint32_t rbo; // Renderbuffer
32 | 
33 | 	uint32_t output;			 // Rendered velocity buffer
34 | 	uint32_t postfilteredOutput; // Postfilter passed velocity buffer
35 | 	// Postfilter applies morphological dilation on velocity buffer to decrease silhouettes
36 | 
37 | 	ResourceRef<Shader> velocityPassShader; // Shader for velocity pass
38 | 	ResourceRef<Shader> postfilterShader; // Shader for performing postfilter pass on velocity buffer
39 | };
40 | 


--------------------------------------------------------------------------------
/nuro-core/scene/scene.cpp:
--------------------------------------------------------------------------------
1 | #include "scene.h"


--------------------------------------------------------------------------------
/nuro-core/scene/scene.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | 
 6 | struct SceneEntity {
 7 | 
 8 | 	
 9 | 
10 | };
11 | 
12 | class Scene {
13 | public:
14 | 
15 | private:
16 | 
17 | };


--------------------------------------------------------------------------------
/nuro-core/scene/scene_manager.cpp:
--------------------------------------------------------------------------------
 1 | #include "scene_manager.h"
 2 | 
 3 | #include "scene.h"
 4 | 
 5 | SceneManager::SceneManager() : scenes() 
 6 | {
 7 | }
 8 | 
 9 | SceneName SceneManager::createScene(std::string name)
10 | {
11 | 	return SceneName();
12 | }
13 | 
14 | SceneName SceneManager::createScene(FS::Path sceneFile)
15 | {
16 | 	return SceneName();
17 | }
18 | 
19 | void SceneManager::loadScene(SceneName name)
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/nuro-core/scene/scene_manager.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | 
 7 | #include <utils/fsutil.h>
 8 | 
 9 | class Scene;
10 | 
11 | using SceneName = std::string;
12 | using SceneRef = std::shared_ptr<Scene>;
13 | 
14 | class SceneManager {
15 | public:
16 | 	SceneManager();
17 | 	
18 | 	// Creates an empty scene with a given name
19 | 	SceneName createScene(std::string name);
20 | 
21 | 	// Creates a scene loaded from a scene file 
22 | 	SceneName createScene(FS::Path sceneFile);
23 | 
24 | 	// Loads a scene by its name
25 | 	void loadScene(SceneName name);
26 | 
27 | private:
28 | 	std::unordered_map<SceneName, SceneRef> scenes;
29 | 
30 | };


--------------------------------------------------------------------------------
/nuro-core/shaders/gizmo/gizmo_fill/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core 
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 v_uv;
 6 | 
 7 | uniform vec4 color;
 8 | 
 9 | void main() {
10 |     FragColor = color;
11 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/gizmo/gizmo_fill/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 2) in vec2 uv_in;
 5 | 
 6 | uniform mat4 mvpMatrix;
 7 | 
 8 | out vec2 v_uv;
 9 | 
10 | void main() 
11 | {
12 |     v_uv = uv_in;
13 | 
14 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
15 | }
16 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/gizmo/gizmo_icon/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core 
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 v_uv;
 6 | 
 7 | uniform sampler2D icon;
 8 | uniform vec3 tint;
 9 | uniform float alpha;
10 | 
11 | void main() {
12 |     vec4 color = texture(icon, v_uv).rgba * vec4(tint, alpha);
13 |     FragColor = color;
14 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/gizmo/gizmo_icon/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 2) in vec2 uv_in;
 5 | 
 6 | uniform mat4 mvpMatrix;
 7 | 
 8 | out vec2 v_uv;
 9 | 
10 | void main() 
11 | {
12 |     v_uv = uv_in;
13 | 
14 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
15 | }
16 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/legacy/lit_legacy/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 1) in vec3 normals_in;
 5 | layout(location = 2) in vec2 textureCoords_in;
 6 | 
 7 | uniform mat4 mvpMatrix;
 8 | uniform mat4 modelMatrix;
 9 | uniform mat4 lightSpaceMatrix;
10 | 
11 | out vec3 v_normals;
12 | out vec3 v_fragmentPosition;
13 | out vec4 v_fragmentLightSpacePosition;
14 | out vec2 v_textureCoords;
15 | 
16 | void main()
17 | {
18 |     v_normals = mat3(transpose(inverse(modelMatrix))) * normals_in;
19 |     v_fragmentPosition = vec3(modelMatrix * vec4(position_in, 1.0));
20 |     v_fragmentLightSpacePosition = lightSpaceMatrix * vec4(v_fragmentPosition, 1.0);
21 |     v_textureCoords = textureCoords_in;
22 | 
23 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
24 | }
25 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/lit/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 1) in vec3 normal_in;
 5 | layout(location = 2) in vec2 uv_in;
 6 | layout(location = 3) in vec3 tangent_in;
 7 | layout(location = 4) in vec3 bitangent_in;
 8 | 
 9 | uniform mat4 mvpMatrix;
10 | uniform mat4 modelMatrix;
11 | uniform mat3 normalMatrix;
12 | uniform mat4 lightSpaceMatrix;
13 | 
14 | out vec3 v_normal;
15 | out vec2 v_uv;
16 | out mat3 v_tbn;
17 | out mat3 v_tbnTransposed;
18 | out vec3 v_fragmentWorldPosition;
19 | out vec4 v_fragmentLightSpacePosition;
20 | 
21 | vec3 getNormal() {
22 |     return normalize(normalMatrix * normal_in);
23 | }
24 | 
25 | mat3 getTBNMatrix() {
26 |     vec3 t = normalize(normalMatrix * tangent_in);
27 |     vec3 b = normalize(normalMatrix * bitangent_in);
28 |     vec3 n = v_normal;
29 |     return mat3(t, b, n);
30 | }
31 | 
32 | vec3 getFragmentWorldPosition() {
33 |     return vec3(modelMatrix * vec4(position_in, 1.0));
34 | }
35 | 
36 | vec4 getFragmentLightSpacePosition() {
37 |     return lightSpaceMatrix * vec4(v_fragmentWorldPosition, 1.0);
38 | }
39 | 
40 | void main()
41 | {
42 |     v_normal = getNormal();
43 |     v_uv = uv_in;
44 |     v_tbn = getTBNMatrix();
45 |     v_tbnTransposed = transpose(v_tbn);
46 |     v_fragmentWorldPosition = getFragmentWorldPosition();
47 |     v_fragmentLightSpacePosition = getFragmentLightSpacePosition();
48 | 
49 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
50 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/mat_unavailable/.frag:
--------------------------------------------------------------------------------
1 | #version 330 core
2 | 
3 | out vec4 FragColor;
4 | 
5 | void main()
6 | {
7 |     FragColor = vec4(1.0, 0.0, 1.0, 1.0);
8 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/mat_unavailable/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | 
 5 | uniform mat4 mvpMatrix;
 6 | 
 7 | void main()
 8 | {
 9 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
10 | }
11 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/skybox/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec3 texture_coordinates;
 6 | 
 7 | uniform samplerCube skybox;
 8 | uniform float emission;
 9 | 
10 | void main() {
11 |     FragColor = texture(skybox, texture_coordinates) * emission;
12 | }
13 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/skybox/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | 
 5 | out vec3 texture_coordinates;
 6 | 
 7 | uniform mat4 viewProjectionMatrix;
 8 | 
 9 | void main() {
10 |     texture_coordinates = position_in;
11 |     vec4 position = viewProjectionMatrix * vec4(position_in, 1.0);
12 |     gl_Position = position.xyww;
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/unlit/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 v_uv;
 6 | 
 7 | uniform vec4 baseColor;
 8 | 
 9 | uniform vec2 tiling;
10 | uniform vec2 offset;
11 | 
12 | uniform bool enableTexture;
13 | uniform sampler2D baseTexture;
14 | 
15 | void main()
16 | {
17 |     vec2 uv = v_uv * tiling + offset;
18 |     vec4 color = baseColor;
19 | 
20 |     if (enableTexture) {
21 |         color = texture(baseTexture, uv) * color;
22 |     }
23 | 
24 |     FragColor = color;
25 | }
26 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/materials/unlit/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 2) in vec2 uv_in;
 5 | 
 6 | uniform mat4 mvpMatrix;
 7 | 
 8 | out vec2 v_uv;
 9 | 
10 | void main()
11 | {
12 |     v_uv = uv_in;
13 | 
14 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
15 | }
16 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/passes/pre_pass/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec3 v_viewNormal;
 6 | 
 7 | vec3 encodeNormalOutput(vec3 normal) {
 8 |     // remap from [-1, 1] to [0, 1]
 9 |     return normal * 0.5 + 0.5;
10 | }
11 | 
12 | void main()
13 | {
14 |     // encode view space normal as color and set as output
15 |     FragColor = vec4(encodeNormalOutput(v_viewNormal), 1.0);
16 | }
17 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/passes/pre_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 1) in vec3 normal_in;
 5 | 
 6 | uniform mat4 mvpMatrix;
 7 | uniform mat3 viewNormalMatrix;
 8 | 
 9 | out vec3 v_viewNormal;
10 | 
11 | vec3 getViewNormal() {
12 |     return normalize(viewNormalMatrix * normal_in);
13 | }
14 | 
15 | void main()
16 | {
17 |     v_viewNormal = getViewNormal();
18 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
19 | }
20 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/passes/shadow_pass/.frag:
--------------------------------------------------------------------------------
1 | #version 330 core
2 | 
3 | void main()
4 | {}
5 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/passes/shadow_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | 
 5 | uniform mat4 lightSpaceMatrix;
 6 | uniform mat4 modelMatrix;
 7 | 
 8 | void main()
 9 | {
10 |     gl_Position = lightSpaceMatrix * modelMatrix * vec4(position_in, 1.0);
11 | }
12 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/bloom_downsampling/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec3 FragColor;
 4 | 
 5 | uniform sampler2D inputTexture;
 6 | uniform vec2 inversedResolution;
 7 | 
 8 | in vec2 uv;
 9 | 
10 | void main()
11 | {
12 |     float x = inversedResolution.x;
13 |     float y = inversedResolution.y;
14 | 
15 |     vec3 a = texture(inputTexture, vec2(uv.x - 2 * x, uv.y + 2 * y)).rgb;
16 |     vec3 b = texture(inputTexture, vec2(uv.x, uv.y + 2 * y)).rgb;
17 |     vec3 c = texture(inputTexture, vec2(uv.x + 2 * x, uv.y + 2 * y)).rgb;
18 | 
19 |     vec3 d = texture(inputTexture, vec2(uv.x - 2 * x, uv.y)).rgb;
20 |     vec3 e = texture(inputTexture, vec2(uv.x, uv.y)).rgb;
21 |     vec3 f = texture(inputTexture, vec2(uv.x + 2 * x, uv.y)).rgb;
22 | 
23 |     vec3 g = texture(inputTexture, vec2(uv.x - 2 * x, uv.y - 2 * y)).rgb;
24 |     vec3 h = texture(inputTexture, vec2(uv.x, uv.y - 2 * y)).rgb;
25 |     vec3 i = texture(inputTexture, vec2(uv.x + 2 * x, uv.y - 2 * y)).rgb;
26 | 
27 |     vec3 j = texture(inputTexture, vec2(uv.x - x, uv.y + y)).rgb;
28 |     vec3 k = texture(inputTexture, vec2(uv.x + x, uv.y + y)).rgb;
29 |     vec3 l = texture(inputTexture, vec2(uv.x - x, uv.y - y)).rgb;
30 |     vec3 m = texture(inputTexture, vec2(uv.x + x, uv.y - y)).rgb;
31 | 
32 |     FragColor = e * 0.125;
33 |     FragColor += (a + c + g + i) * 0.03125;
34 |     FragColor += (b + d + f + h) * 0.0625;
35 |     FragColor += (j + k + l + m) * 0.125;
36 |     FragColor = max(FragColor, 0.0001f);
37 | }
38 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/bloom_downsampling/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(position_in, 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/bloom_prefilter/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 uv;
 6 | 
 7 | uniform sampler2D inputTexture;
 8 | uniform float threshold;
 9 | uniform float softThreshold;
10 | 
11 | vec3 applyThreshold(vec3 color) {
12 |     float brightness = max(color.r, max(color.g, color.b));
13 |     float knee = threshold * softThreshold;
14 |     float soft = brightness - threshold + knee;
15 |     soft = clamp(soft, 0, knee * 2);
16 |     soft = soft * soft / (knee * 4 + 0.00001);
17 |     float contribution = max(0, brightness - threshold);
18 |     contribution /= max(brightness, 0.00001);
19 |     return color * contribution;
20 | }
21 | 
22 | void main()
23 | {
24 |     vec3 color = texture(inputTexture, uv).rgb;
25 |     FragColor = vec4(applyThreshold(color), 1.0);
26 | }
27 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/bloom_prefilter/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/bloom_upsampling/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec3 FragColor;
 4 | 
 5 | uniform sampler2D inputTexture;
 6 | uniform float filterRadius;
 7 | uniform float aspectRatio;
 8 | 
 9 | in vec2 uv;
10 | 
11 | void main()
12 | {
13 |     float x = filterRadius;
14 |     float y = filterRadius * aspectRatio;
15 | 
16 |     vec3 a = texture(inputTexture, vec2(uv.x - x, uv.y + y)).rgb;
17 |     vec3 b = texture(inputTexture, vec2(uv.x, uv.y + y)).rgb;
18 |     vec3 c = texture(inputTexture, vec2(uv.x + x, uv.y + y)).rgb;
19 | 
20 |     vec3 d = texture(inputTexture, vec2(uv.x - x, uv.y)).rgb;
21 |     vec3 e = texture(inputTexture, vec2(uv.x, uv.y)).rgb;
22 |     vec3 f = texture(inputTexture, vec2(uv.x + x, uv.y)).rgb;
23 | 
24 |     vec3 g = texture(inputTexture, vec2(uv.x - x, uv.y - y)).rgb;
25 |     vec3 h = texture(inputTexture, vec2(uv.x, uv.y - y)).rgb;
26 |     vec3 i = texture(inputTexture, vec2(uv.x + x, uv.y - y)).rgb;
27 | 
28 |     FragColor = e * 4.0;
29 |     FragColor += (b + d + f + h) * 2.0;
30 |     FragColor += (a + c + g + i);
31 |     FragColor *= 1.0 / 16.0;
32 | }
33 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/bloom_upsampling/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/debug_pass/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 uv;
 6 | 
 7 | uniform sampler2D inputTexture;
 8 | uniform vec2 resolution;
 9 | 
10 | const float offset = 1.0 / 300.0;
11 | 
12 | void main()
13 | {
14 |     // FragColor = texture(inputTexture, uv);
15 |     FragColor = vec4(1.0, 0.0, 0.0, 1.0);
16 | }
17 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/debug_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/final_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/motion_blur_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(position_in, 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/ssao_blur/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 uv;
 6 | 
 7 | uniform sampler2D ssaoInput;
 8 | 
 9 | void main() {
10 |     vec2 texelSize = 1.0 / vec2(textureSize(ssaoInput, 0));
11 |     float blurResult = 0.0;
12 |     for (int x = -2; x < 2; ++x) {
13 |         for (int y = -2; y < 2; ++y) {
14 |             vec2 offset = vec2(float(x), float(y)) * texelSize;
15 |             blurResult += texture(ssaoInput, uv + offset).r;
16 |         }
17 |     }
18 |     float occlusion = blurResult / (4.0 * 4.0);
19 | 
20 |     FragColor = vec4(occlusion, 0.0, 0.0, 1.0);
21 | }
22 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/ssao_blur/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/ssao_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/velocity_pass/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec4 v_viewPosition;
 6 | in vec4 v_position;
 7 | in vec4 v_previousPosition;
 8 | 
 9 | uniform float intensity;
10 | 
11 | void main() {
12 |     // calculate velocity
13 |     vec2 current = v_position.xy / v_position.w;
14 |     vec2 previous = v_previousPosition.xy / v_previousPosition.w;
15 |     vec2 velocity = (current - previous) * 0.5;
16 |     velocity *= intensity;
17 | 
18 |     // get depth in view space
19 |     float viewSpaceDepth = v_viewPosition.z;
20 | 
21 |     // RED CHANNEL = x velocity | GREEN CHANNEL = y velocity | BLUE CHANNEL = view space depth
22 |     FragColor = vec4(velocity.x, velocity.y, viewSpaceDepth, 1.0);
23 | }
24 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/velocity_pass/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | 
 5 | uniform mat4 modelMatrix;
 6 | uniform mat4 previousModelMatrix;
 7 | uniform mat4 viewMatrix;
 8 | uniform mat4 projectionMatrix;
 9 | 
10 | out vec4 v_viewPosition;
11 | out vec4 v_position;
12 | out vec4 v_previousPosition;
13 | 
14 | void main()
15 | {
16 |     vec4 worldPosition = modelMatrix * vec4(position_in, 1.0);
17 |     vec4 previousWorldPosition = previousModelMatrix * vec4(position_in, 1.0);
18 | 
19 |     v_viewPosition = viewMatrix * worldPosition;
20 |     v_position = projectionMatrix * v_viewPosition;
21 |     v_previousPosition = projectionMatrix * viewMatrix * previousWorldPosition;
22 | 
23 |     gl_Position = v_position;
24 | }
25 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/velocity_postfilter/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 uv;
 6 | 
 7 | uniform vec2 resolution;
 8 | uniform sampler2D velocityBuffer;
 9 | 
10 | void main() {
11 |     vec3 bufferSample = texture(velocityBuffer, uv).rgb;
12 |     vec2 velocitySample = bufferSample.rg;
13 | 
14 |     FragColor = vec4(velocitySample, bufferSample.b, 1.0);
15 | }
16 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/postprocessing/velocity_postfilter/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec2 position_in;
 4 | layout(location = 1) in vec2 uv_in;
 5 | 
 6 | out vec2 uv;
 7 | 
 8 | void main()
 9 | {
10 |     uv = uv_in;
11 | 
12 |     gl_Position = vec4(position_in, 0.0, 1.0);
13 | }
14 | 


--------------------------------------------------------------------------------
/nuro-core/shaders/startup/startup_background/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | out vec4 FragColor;
 4 | 
 5 | in vec2 v_uv;
 6 | 
 7 | uniform float time;
 8 | 
 9 | void main() {
10 |     // Normalize UV coordinates to center the effect
11 |     vec2 uv = v_uv * 2.0 - 1.0;
12 | 
13 |     // Calculate the distance from the center
14 |     float dist = length(uv);
15 | 
16 |     // Create a ripple effect using sine waves and time
17 |     float ripple = sin(10.0 * dist - time * 2.0);
18 | 
19 |     // Map ripple to a color gradient
20 |     vec3 color = vec3(0.5 + 0.5 * cos(time + vec3(0.0, 2.0, 4.0)));
21 | 
22 |     // Modulate the color intensity by the ripple effect
23 |     float intensity = smoothstep(0.0, 1.0, ripple);
24 | 
25 |     // Final color output
26 |     FragColor = vec4(color * intensity, 1.0);
27 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/startup/startup_background/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 2) in vec2 uv_in;
 5 | 
 6 | out vec2 v_uv;
 7 | 
 8 | void main() 
 9 | {
10 |     v_uv = uv_in;
11 | 
12 |     gl_Position = vec4(vec2(position_in), 0.0, 1.0);
13 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/startup/startup_model/.frag:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | // input attributes from vertex shader
 4 | in vec3 v_normal; // normal vector at each fragment
 5 | in vec2 v_uv;     // texture coordinates
 6 | 
 7 | // uniforms for material properties and texture
 8 | uniform sampler2D colorTexture;  // color texture for the object
 9 | uniform vec4 baseColor;          // base color of the object
10 | 
11 | // shading constants
12 | const vec3 lightPosition = vec3(3.0, 3.0, 5.5);      // position of light source
13 | const vec3 lightColor = vec3(1.0);         // color of light source
14 | const vec3 cameraPosition = vec3(0.0);     // camera position
15 | 
16 | const float ambientStrength = 0.1;   // ambient light strength
17 | const float diffuseStrength = 0.8;   // diffuse light strength
18 | const float specularStrength = 1.0;  // specular strength
19 | const float shininess = 32.0;        // shininess coefficient
20 | 
21 | // outputs the fragment color
22 | out vec4 FragColor;
23 | 
24 | // main shading function implementing blinn-phong model
25 | vec4 shade() {
26 |     // normalize normal vector (ensure correct lighting calculations)
27 |     vec3 normal = normalize(v_normal);
28 |     
29 |     // calculate direction to light source
30 |     vec3 lightDir = normalize(lightPosition - vec3(0.0, 0.0, 0.0)); // camera at (0,0,0)
31 |     
32 |     // ambient lighting component (slight constant lighting)
33 |     vec3 ambient = ambientStrength * lightColor;
34 |     
35 |     // diffuse lighting component (lambertian reflection)
36 |     float diff = max(dot(normal, lightDir), 0.0); // diffuse factor
37 |     vec3 diffuse = diffuseStrength * diff * lightColor;
38 |     
39 |     // specular lighting component (blinn-phong specular reflection)
40 |     // calculate view direction (from fragment to camera)
41 |     vec3 viewDir = normalize(cameraPosition - vec3(0.0, 0.0, 0.0)); // camera at (0,0,0)
42 |     
43 |     // halfway vector between light direction and view direction
44 |     vec3 halfwayDir = normalize(lightDir + viewDir);
45 |     
46 |     // calculate specular highlight (using blinn-phong model)
47 |     float spec = pow(max(dot(normal, halfwayDir), 0.0), shininess);
48 |     vec3 specular = specularStrength * spec * lightColor;
49 |     
50 |     // combine all lighting components
51 |     vec3 lighting = ambient + diffuse + specular;
52 |     
53 |     // sample color from texture and apply lighting
54 |     vec4 colorSample = texture(colorTexture, v_uv).rgba;
55 |     
56 |     // final color = material color * lighting
57 |     return baseColor * colorSample * vec4(lighting, 1.0);
58 | }
59 | 
60 | void main() {
61 |     // output final fragment color using shade function
62 |     FragColor = shade();
63 | }


--------------------------------------------------------------------------------
/nuro-core/shaders/startup/startup_model/.vert:
--------------------------------------------------------------------------------
 1 | #version 330 core
 2 | 
 3 | layout(location = 0) in vec3 position_in;
 4 | layout(location = 1) in vec3 normal_in;
 5 | layout(location = 2) in vec2 uv_in;
 6 | layout(location = 3) in vec3 tangent_in;
 7 | layout(location = 4) in vec3 bitangent_in;
 8 | 
 9 | uniform mat4 mvpMatrix;
10 | uniform mat3 normalMatrix;
11 | 
12 | out vec3 v_normal;
13 | out vec2 v_uv;
14 | 
15 | void main(){
16 |     v_normal = normalize(normalMatrix * normal_in);
17 |     v_uv = uv_in;
18 |     
19 |     gl_Position = mvpMatrix * vec4(position_in, 1.0);
20 | }


--------------------------------------------------------------------------------
/nuro-core/time/time.cpp:
--------------------------------------------------------------------------------
 1 | #include "time.h"
 2 | 
 3 | namespace Time {
 4 | 
 5 | 	double gTime = 0.0;
 6 | 	double gLastTime = 0.0;
 7 | 	double gUnscaledDelta = 0.0;
 8 | 	double gDelta = 0.0;
 9 | 	double gTimeScale = 1.0;
10 | 
11 | 	void step(double time)
12 | 	{
13 | 		gTime = static_cast<float>(time);
14 | 		gUnscaledDelta = gTime - gLastTime;
15 | 		gDelta = gUnscaledDelta * gTimeScale;
16 | 		gLastTime = gTime;
17 | 	}
18 | 
19 | 	double now()
20 | 	{
21 | 		return gTime;
22 | 	}
23 | 
24 | 	float nowf()
25 | 	{
26 | 		return static_cast<float>(gTime);
27 | 	}
28 | 
29 | 	double last()
30 | 	{
31 | 		return gLastTime;
32 | 	}
33 | 
34 | 	float lastf()
35 | 	{
36 | 		return static_cast<float>(gLastTime);
37 | 	}
38 | 
39 | 	double delta()
40 | 	{
41 | 		return gDelta;
42 | 	}
43 | 
44 | 	float deltaf()
45 | 	{
46 | 		return static_cast<float>(gDelta);
47 | 	}
48 | 
49 | 	double unscaledDelta()
50 | 	{
51 | 		return gUnscaledDelta;
52 | 	}
53 | 
54 | 	double unscaledDeltaf()
55 | 	{
56 | 		return static_cast<float>(gUnscaledDelta);
57 | 	}
58 | 
59 | 	double getTimeScale()
60 | 	{
61 | 		return gTimeScale;
62 | 	}
63 | 
64 | 	void setTimeScale(double timeScale)
65 | 	{
66 | 		gTimeScale = timeScale;
67 | 	}
68 | 
69 | }


--------------------------------------------------------------------------------
/nuro-core/time/time.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | namespace Time
 3 | {
 4 | 	// Calculate times for current frame (handled by application context)
 5 | 	void step(double time);
 6 | 
 7 | 	// Returns the current application time
 8 | 	double now();
 9 | 
10 | 	// Returns the current application time
11 | 	float nowf();
12 | 
13 | 	// Returns the application time of last frame
14 | 	double last();
15 | 
16 | 	// Returns the application time of last frame
17 | 	float lastf();
18 | 
19 | 	// Returns the current delta time not affected by the time scale
20 | 	double unscaledDelta();
21 | 
22 | 	// Returns the current delta time not affected by the time scale
23 | 	double unscaledDeltaf();
24 | 
25 | 	// Returns the current delta time
26 | 	double delta();
27 | 
28 | 	// Returns the current delta time
29 | 	float deltaf();
30 | 
31 | 	// Returns the current time scale
32 | 	double getTimeScale();
33 | 
34 | 	// Sets the time scale
35 | 	void setTimeScale(double timeScale);
36 | };


--------------------------------------------------------------------------------
/nuro-core/transform/transform_pass.cpp:
--------------------------------------------------------------------------------
 1 | #include "transform_pass.h"
 2 | 
 3 | #include <algorithm>
 4 | 
 5 | #include <ecs/ecs_collection.h>
 6 | #include <transform/transform.h>
 7 | #include <diagnostics/profiler.h>
 8 | 
 9 | void TransformPass::perform(glm::mat4 viewProjection)
10 | {
11 | 	// Evaluate transforms
12 | 	for (auto [entity, transform] : ECS::main().view<TransformComponent>().each()) {
13 | 		// Evaluate root node
14 | 		if (Transform::isRoot(transform)) evaluate(transform);
15 | 
16 | 		// Update transforms model-view-projection
17 | 		Transform::updateMvp(transform, viewProjection);
18 | 	}
19 | }
20 | 
21 | void TransformPass::evaluate(TransformComponent& transform)
22 | {
23 | 	if(transform.modified) Transform::evaluate(transform);
24 | 
25 | 	for (Entity child : transform.children) {
26 | 		evaluate(ECS::main().get<TransformComponent>(child), transform, transform.modified);
27 | 	}
28 | 
29 | 	transform.modified = false;
30 | }
31 | 
32 | void TransformPass::evaluate(TransformComponent& transform, TransformComponent& parent, bool propagateModified)
33 | {
34 | 	if (propagateModified) transform.modified = true;
35 | 
36 | 	if(transform.modified) Transform::evaluate(transform, parent);
37 | 
38 | 	for (Entity child : transform.children) {
39 | 		evaluate(ECS::main().get<TransformComponent>(child), transform, transform.modified);
40 | 	}
41 | 
42 | 	transform.modified = false; 
43 | }


--------------------------------------------------------------------------------
/nuro-core/transform/transform_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include <transform/transform.h>
 7 | 
 8 | class TransformPass
 9 | {
10 | public:
11 | 	// Performs the preprocessing needed before rendering for all entities
12 | 	void perform(glm::mat4 viewProjection);
13 | 
14 | private:
15 | 	void evaluate(TransformComponent& transform);
16 | 	void evaluate(TransformComponent& transform, TransformComponent& parent, bool propagateModified);
17 | };


--------------------------------------------------------------------------------
/nuro-core/utils/callback.h:
--------------------------------------------------------------------------------
 1 | #include <functional>
 2 | 
 3 | template <typename... Args>
 4 | class Callback
 5 | {
 6 | public:
 7 | 	using FuncType = std::function<void(Args...)>;
 8 | 
 9 | 	Callback() = default;
10 | 	Callback(FuncType func) : callback(std::move(func)) {};
11 | 
12 | 	void operator()(Args... args) const 
13 | 	{
14 | 		if (callback) callback(std::forward<Args>(args)...);
15 | 	}
16 | 
17 | 	explicit operator bool() const noexcept {
18 | 		return static_cast<bool>(callback);
19 | 	}
20 | 
21 | private:
22 | 	FuncType callback;
23 | };


--------------------------------------------------------------------------------
/nuro-core/utils/console.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <string>
  4 | #include <functional>
  5 | 
  6 | #include <utils/event.h>
  7 | 
  8 | namespace Console
  9 | {
 10 | 
 11 | 	//
 12 | 	// TEXT COLORS
 13 | 	//
 14 | 
 15 | 	enum class TextColor
 16 | 	{
 17 | 		DEFAULT = 39,
 18 | 		BLACK = 30,
 19 | 		RED = 31,
 20 | 		GREEN = 32,
 21 | 		YELLOW = 33,
 22 | 		BLUE = 34,
 23 | 		MAGENTA = 35,
 24 | 		CYAN = 36,
 25 | 		WHITE = 37,
 26 | 		GRAY = 90
 27 | 	};
 28 | 
 29 | 	//
 30 | 	// BACKGROUND COLORS
 31 | 	//
 32 | 
 33 | 	enum class BgColor
 34 | 	{
 35 | 		NONE = 49,
 36 | 		BLACK = 40,
 37 | 		RED = 41,
 38 | 		GREEN = 42,
 39 | 		YELLOW = 43,
 40 | 		BLUE = 44,
 41 | 		MAGENTA = 45,
 42 | 		CYAN = 46,
 43 | 		WHITE = 47	
 44 | 	};
 45 | 
 46 | 	//
 47 | 	// OUTPUT TAGS
 48 | 	//
 49 | 
 50 | 	class EndLine {};
 51 | 	class ResetText {};
 52 | 	class ResetBg {};
 53 | 
 54 | 	//
 55 | 	// PRINTER
 56 | 	//
 57 | 
 58 | 	class Printer {
 59 | 	private:
 60 | 		TextColor textColor;
 61 | 		BgColor bgColor;
 62 | 
 63 | 	public:
 64 | 		Printer();
 65 | 		~Printer();
 66 | 
 67 | 		Printer& operator>>(const std::string& text);
 68 | 		Printer& operator>>(TextColor color);
 69 | 		Printer& operator>>(BgColor color);
 70 | 
 71 | 		Printer& operator>>(EndLine endl);
 72 | 		Printer& operator>>(ResetText resetText);
 73 | 		Printer& operator>>(ResetBg resetBg);
 74 | 
 75 | 	};
 76 | 
 77 | 	//
 78 | 	// INSTANCES
 79 | 	//
 80 | 
 81 | 	inline EndLine endl;
 82 | 	inline ResetText resetText;
 83 | 	inline ResetBg resetBg;
 84 | 	inline Printer print;
 85 | 
 86 | 	//
 87 | 	// PREFABRICATED OUTPUT
 88 | 	//
 89 | 
 90 | 	namespace out {
 91 | 
 92 | 		enum class LogType {
 93 | 			DEFAULT,
 94 | 			WARNING,
 95 | 			ERROR
 96 | 		};
 97 | 
 98 | 		// Returns the log event (parameters: origin, content and log type)
 99 | 		Event<const std::string&, const std::string&, LogType>& logEvent();
100 | 
101 | 		// Prints an error
102 | 		void error(std::string origin, std::string error, std::string additionalInfo = "");
103 | 
104 | 		// Prints a warning
105 | 		void warning(std::string origin, std::string warning, std::string additionalInfo = "");
106 | 
107 | 		// Prints that some specified process has started
108 | 		void start(std::string origin, std::string info);
109 | 
110 | 		// Prints an information
111 | 		void info(std::string info);
112 | 
113 | 		// Prints an information
114 | 		void info(std::string origin, std::string info);
115 | 
116 | 		// Prints that some specified process is done
117 | 		void done(std::string origin, std::string info);
118 | 
119 | 		// Prints a highlighted debug message
120 | 		void debug(std::string origin, std::string info);
121 | 
122 | 		// Prints the ASCII welcome message
123 | 		void welcome();
124 | 
125 | 	}
126 | };


--------------------------------------------------------------------------------
/nuro-core/utils/event.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <vector>
 5 | 
 6 | #include <utils/callback.h>
 7 | 
 8 | template <typename... Args>
 9 | class Event {
10 | public:
11 | 	using FuncType = std::function<void(Args...)>;
12 | 	using CallbackType = Callback<Args...>;
13 | 	using CallbackPointer = std::shared_ptr<CallbackType>;
14 | 
15 | 	CallbackPointer subscribe(CallbackType callback) {
16 | 		auto callbackPointer = std::make_shared<CallbackType>(std::move(callback));
17 | 		callbacks.emplace_back(callbackPointer);
18 | 		return callbackPointer;
19 | 	}
20 | 
21 | 	CallbackPointer subscribe(FuncType func) {
22 | 		auto callbackPointer = std::make_shared<CallbackType>(std::move(func));
23 | 		callbacks.emplace_back(callbackPointer);
24 | 		return callbackPointer;
25 | 	}
26 | 
27 | 	void unsubscribe(CallbackPointer callback) {
28 | 		callbacks.erase(std::remove(callbacks.begin(), callbacks.end(), callback), callbacks.end());
29 | 	}
30 | 
31 | 	void operator()(Args... args) const {
32 | 		for (const auto& callback : callbacks) {
33 | 			if (callback) {
34 | 				(*callback)(std::forward<Args>(args)...);
35 | 			}
36 | 		}
37 | 	}
38 | 
39 | private:
40 | 	std::vector<CallbackPointer> callbacks;
41 | };


--------------------------------------------------------------------------------
/nuro-core/utils/format.cpp:
--------------------------------------------------------------------------------
 1 | #include "format.h"
 2 | 
 3 | #include <cctype>
 4 | #include <algorithm>
 5 | 
 6 | namespace Format {
 7 | 
 8 |     std::string snakeCase(std::string str) {
 9 |         std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) {
10 |             return std::isspace(c) ? '_' : std::tolower(c);
11 |             });
12 |         return str;
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/nuro-core/utils/format.h:
--------------------------------------------------------------------------------
1 | #include <string>
2 | 
3 | namespace Format {
4 | 
5 |     // Converts given string to snake case
6 |     std::string snakeCase(std::string str);
7 | 
8 | }


--------------------------------------------------------------------------------
/nuro-core/utils/string_helper.cpp:
--------------------------------------------------------------------------------
 1 | #include "string_helper.h"
 2 | 
 3 | namespace StringHelper
 4 | {
 5 | 
 6 | 	bool startsWith(const std::string& str, const std::string& prefix)
 7 | 	{
 8 | 		// Check if string is shorter than prefix
 9 | 		if (str.length() < prefix.length())
10 | 		{
11 | 			return false;
12 | 		}
13 | 		// Compare beginning of string with prefix
14 | 		return str.compare(0, prefix.length(), prefix) == 0;
15 | 	}
16 | 
17 | 	std::vector<std::string> split(const std::string& str, const std::string& delimiter)
18 | 	{
19 | 		std::vector<std::string> result;
20 | 		size_t start = 0;
21 | 		size_t end = str.find(delimiter);
22 | 
23 | 		// Loop until no more delimiters are found
24 | 		while (end != std::string::npos)
25 | 		{
26 | 			// Add the substring before the delimiter to the result
27 | 			result.push_back(str.substr(start, end - start));
28 | 			// Move past the delimiter
29 | 			start = end + delimiter.length();
30 | 			// Find the next delimiter
31 | 			end = str.find(delimiter, start);
32 | 		}
33 | 		// Add the last segment after the final delimiter
34 | 		result.push_back(str.substr(start));
35 | 
36 | 		return result;
37 | 	}
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/nuro-core/utils/string_helper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | 
 6 | namespace StringHelper
 7 | {
 8 | 
 9 | 	// Checks if a string starts with a prefix
10 | 	bool startsWith(const std::string& str, const std::string& prefix);
11 | 
12 | 	// Splits a string by a delimiter
13 | 	std::vector<std::string> split(const std::string& str, const std::string& delimiter);
14 | 
15 | };
16 | 


--------------------------------------------------------------------------------
/nuro-core/viewport/viewport.cpp:
--------------------------------------------------------------------------------
 1 | #include "viewport.h"
 2 | 
 3 | #include <algorithm>
 4 | 
 5 | Viewport::Viewport() : width(0.0f), height(0.0f)
 6 | {
 7 | 	resize(width, height);
 8 | }
 9 | 
10 | Viewport::Viewport(float _width, float _height) : width(_width), height(_height)
11 | {
12 | 	resize(width, height);
13 | }
14 | 
15 | void Viewport::resize(float _width, float _height)
16 | {
17 | 	_width = std::max(_width, 1.0f);
18 | 	_height = std::max(_height, 1.0f);
19 | 
20 | 	width = _width;
21 | 	height = _height;
22 | }
23 | 
24 | float Viewport::getWidth() const
25 | {
26 | 	return width;
27 | }
28 | 
29 | float Viewport::getHeight() const
30 | {
31 | 	return height;
32 | }
33 | 
34 | uint32_t Viewport::getWidth_i() const
35 | {
36 | 	return static_cast<uint32_t>(width);
37 | }
38 | 
39 | uint32_t Viewport::getHeight_i() const
40 | {
41 | 	return static_cast<uint32_t>(height);
42 | }
43 | 
44 | GLsizei Viewport::getWidth_gl() const
45 | {
46 | 	return static_cast<GLsizei>(width);
47 | }
48 | 
49 | GLsizei Viewport::getHeight_gl() const
50 | {
51 | 	return static_cast<GLsizei>(height);
52 | }
53 | 
54 | glm::vec2 Viewport::getResolution() const
55 | {
56 | 	return glm::vec2(width, height);
57 | }
58 | 
59 | glm::ivec2 Viewport::getResolution_i() const
60 | {
61 | 	return glm::ivec2(static_cast<uint32_t>(width), static_cast<uint32_t>(height));
62 | }
63 | 
64 | float Viewport::getAspect() const
65 | {
66 | 	return width / height;
67 | }
68 | 


--------------------------------------------------------------------------------
/nuro-core/viewport/viewport.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <glad/glad.h>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | class Viewport
 8 | {
 9 | public:
10 | 	Viewport();
11 | 	Viewport(float width, float height);
12 | 
13 | 	// Resizes the viewport to the specified width and height
14 | 	void resize(float width, float height);
15 | 
16 | 	// Returns the width of the viewport
17 | 	float getWidth() const;
18 | 
19 | 	// Returns the height of the viewport
20 | 	float getHeight() const;
21 | 
22 | 	// Returns the width of the viewport as an unsigned integer
23 | 	uint32_t getWidth_i() const;
24 | 
25 | 	// Returns the height of the viewport as an unsigned integer
26 | 	uint32_t getHeight_i() const;
27 | 
28 | 	// Returns the width of the viewport as a gl size type
29 | 	GLsizei getWidth_gl() const;
30 | 
31 | 	// Returns the height of the viewport as a gl size type
32 | 	GLsizei getHeight_gl() const;
33 | 
34 | 	// Returns the resolution of the viewport as a vector
35 | 	glm::vec2 getResolution() const;
36 | 
37 | 	// Returns the resolution of the viewport as an integer vector
38 | 	glm::ivec2 getResolution_i() const;
39 | 
40 | 	// Returns the aspect ratio of the viewport
41 | 	float getAspect() const;
42 | 
43 | private:
44 | 	float width;
45 | 	float height;
46 | };


--------------------------------------------------------------------------------
/nuro-editor/assetsys/asset_meta.cpp:
--------------------------------------------------------------------------------
 1 | #include "asset_meta.h"
 2 | 
 3 | namespace AssetMeta {
 4 | 
 5 | 	AssetGUID parseGUID(const FS::Path& path)
 6 |     {
 7 | 		try {
 8 | 			// Ensure metadata file is valid
 9 | 			if (!FS::exists(path))
10 | 				return AssetGUID();
11 | 
12 | 			// Open metadata file
13 | 			std::ifstream file(path);
14 | 			if (!file.is_open()) {
15 | 				return AssetGUID();
16 | 			}
17 | 
18 | 			// Read first line of metadata file (containing guid)
19 | 			std::string line;
20 | 			if (!std::getline(file, line))
21 | 				return AssetGUID();
22 | 
23 | 			// Extract guid string
24 | 			const std::string guidPrefix = "guid: ";
25 | 			if (line.rfind(guidPrefix, 0) != 0)
26 | 				return AssetGUID();
27 | 			std::string guidStr = line.substr(guidPrefix.length());
28 | 
29 | 			return AssetGUID(guidStr);
30 | 		}
31 | 		catch (...) {
32 | 			return AssetGUID();
33 | 		}
34 |     }
35 | 
36 | 	std::string createHeader(AssetGUID guid)
37 | 	{
38 | 		return "guid: " + guid.str() + "\n---\n";
39 | 	}
40 | 
41 | 	void removeHeader(std::string& source)
42 | 	{
43 | 		try {
44 | 			// Find header document separator
45 | 			size_t separatorPos = source.find("---");
46 | 			if (separatorPos == std::string::npos) return;
47 | 
48 | 			size_t newlineAfterSeparator = source.find('\n', separatorPos);
49 | 			if (newlineAfterSeparator == std::string::npos) return;
50 | 
51 | 			// Remove header
52 | 			source = source.substr(newlineAfterSeparator + 1);
53 | 		}
54 | 		catch (const std::exception& e) {
55 | 			Console::out::warning("Asset Meta", "Failed to remove header: " + std::string(e.what()));
56 | 		}
57 | 	}
58 | 
59 | }


--------------------------------------------------------------------------------
/nuro-editor/assetsys/asset_meta.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <string>
  4 | #include <utility>
  5 | #include <optional>
  6 | 
  7 | #include <rfl.hpp>
  8 | #include <rfl/json.hpp>
  9 | #include <nlohmann/json.hpp>
 10 | 
 11 | #include <utils/guid.h>
 12 | #include <utils/fsutil.h>
 13 | #include <utils/console.h>
 14 | 
 15 | // Global asset id
 16 | using AssetGUID = XG::GUID;
 17 | 
 18 | // Session-only runtime id of an asset
 19 | using AssetSID = uint32_t;
 20 | 
 21 | struct AssetKey {
 22 | 	AssetGUID guid;
 23 | 	AssetSID sessionID = 0;
 24 | };
 25 | 
 26 | namespace AssetMeta {
 27 | 
 28 | 	// Returns the guid from the header of a metadata file
 29 | 	AssetGUID parseGUID(const FS::Path& path);
 30 | 
 31 | 	// Create header for metadata file
 32 | 	std::string createHeader(AssetGUID guid);
 33 | 
 34 | 	// Remove header from metadata file source
 35 | 	void removeHeader(std::string& source);
 36 | 
 37 | 	// Serializes a metadata object into a metadata file, returns success
 38 | 	template <typename T>
 39 | 	bool serialize(const T& obj, const FS::Path& path) {
 40 | 		// Try to serialize object
 41 | 		std::string serialized;
 42 | 		try {
 43 | 			serialized = rfl::json::write(obj);
 44 | 			auto json = nlohmann::json::parse(serialized);
 45 | 			serialized = json.dump(4);
 46 | 		}
 47 | 		catch (const std::exception& e) {
 48 | 			std::string err = std::string(e.what());
 49 | 			Console::out::warning("Asset Meta", "Failed to serialize some assets metadata: " + err);
 50 | 			return false;
 51 | 		}
 52 | 
 53 | 		// Add guid header to serialized string
 54 | 		std::string header = createHeader(parseGUID(path));
 55 | 		serialized.insert(0, header);
 56 | 
 57 | 		// Write serialized object to metadata file
 58 | 		FS::writeFile(path, serialized);
 59 | 
 60 | 		return true;
 61 | 	}
 62 | 
 63 | 	// Deserializes a metadata file, returns optional of deserialized object depending on success
 64 | 	template <typename T>
 65 | 	std::optional<T> deserialize(const FS::Path& path) {
 66 | 		// Read meta file source
 67 | 		std::string source = FS::readFile(path);
 68 | 
 69 | 		// Remove header from metadata source
 70 | 		removeHeader(source);
 71 | 
 72 | 		// Ensure metadata source is available
 73 | 		if (source.empty())
 74 | 			return std::nullopt;
 75 | 
 76 | 		// Try to deserialize metadata source
 77 | 		try {
 78 | 			const T obj = rfl::json::read<T>(source).value();
 79 | 			return obj;
 80 | 		}
 81 | 		catch (const std::exception& e) {
 82 | 			std::string err = std::string(e.what());
 83 | 			Console::out::warning("Asset Meta", "Failed to deserialize some assets metadata: " + err);
 84 | 			return std::nullopt;
 85 | 		}
 86 | 	}
 87 | 
 88 | 	// Loads an assets metadata from a metadata file
 89 | 	template <typename T>
 90 | 	void loadMeta(T* slot, const FS::Path& path) {
 91 | 		auto meta = deserialize<T>(path);
 92 | 		if (!meta) {
 93 | 			*slot = T();
 94 | 			AssetMeta::serialize(*slot, path);
 95 | 		}
 96 | 		else {
 97 | 			*slot = meta.value();
 98 | 		}
 99 | 	}
100 | 
101 | }


--------------------------------------------------------------------------------
/nuro-editor/assetsys/editor_asset.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | #include <cstdint>
 6 | 
 7 | #include <utils/fsutil.h>
 8 | 
 9 | #include "asset_meta.h"
10 | 
11 | class ProjectAssets;
12 | 
13 | enum class AssetType {
14 | 	FALLBACK,
15 | 
16 | 	ANIMATION,
17 | 	AUDIO_CLIP,
18 | 	FONT,
19 | 	MATERIAL,
20 | 	MODEL,
21 | 	TEXTURE
22 | };
23 | 
24 | class EditorAsset {
25 | private:
26 | 	friend class ProjectAssets;
27 | 
28 | 	// Assets id
29 | 	AssetKey _assetKey;
30 | 
31 | 	// Type of the asset
32 | 	AssetType _assetType;
33 | 
34 | 	// Path to asset relative to project root
35 | 	FS::Path _assetPath;
36 | 
37 | 	// List of assets this asset depends on
38 | 	std::vector<AssetGUID> _assetDependencies;
39 | 
40 | 	// If asset is currently loading
41 | 	bool _assetLoading;
42 | 
43 | protected:
44 | 	EditorAsset() : _assetKey(), _assetType(AssetType::FALLBACK), _assetPath(), _assetDependencies(), _assetLoading(false) {};
45 | 
46 | public:
47 | 	virtual ~EditorAsset() = 0;
48 | 
49 | 	// Returns the editor assets key
50 | 	AssetKey key() const {
51 | 		return _assetKey;
52 | 	}
53 | 
54 | 	// Returns the type of the asset
55 | 	AssetType type() const {
56 | 		return _assetType;
57 | 	}
58 | 
59 | 	// Returns the path to the asset relative to project root path
60 | 	FS::Path path() const {
61 | 		return _assetPath;
62 | 	}
63 | 
64 | 	// Returns the editor assets dependencies
65 | 	const auto& dependencies() const {
66 | 		return _assetDependencies;
67 | 	}
68 | 
69 | 	// Returns if the asset is currently in a loading state
70 | 	bool loading() const {
71 | 		return _assetLoading;
72 | 	}
73 | 
74 | 	// Event when the asset is first loaded within the editor
75 | 	virtual void onDefaultLoad(const FS::Path& metaPath) = 0;
76 | 
77 | 	// Event when the asset is unloaded or destroyed within the editor
78 | 	virtual void onUnload() = 0;
79 | 
80 | 	// Event when the asset is reloaded, e.g. due to file modifications
81 | 	virtual void onReload() = 0;
82 | 
83 | 	// Renders the assets insight panel inspectable ui
84 | 	virtual void renderInspectableUI() = 0;
85 | 
86 | 	// Returns the assets icon
87 | 	virtual uint32_t icon() const = 0;
88 | };
89 | 
90 | inline EditorAsset::~EditorAsset() {}


--------------------------------------------------------------------------------
/nuro-editor/assetsys/fallback_asset.cpp:
--------------------------------------------------------------------------------
 1 | #include "fallback_asset.h"
 2 | 
 3 | #include <rendering/icons/icon_pool.h>
 4 | 
 5 | #include "../ui/windows/insight_panel_window.h"
 6 | 
 7 | FallbackAsset::FallbackAsset() : meta()
 8 | {
 9 | }
10 | 
11 | FallbackAsset::~FallbackAsset()
12 | {
13 | }
14 | 
15 | void FallbackAsset::onDefaultLoad(const FS::Path& metaPath)
16 | {
17 | 	AssetMeta::loadMeta<Meta>(&meta, metaPath);
18 | }
19 | 
20 | void FallbackAsset::onUnload()
21 | {
22 | 	// Nothing to unload
23 | }
24 | 
25 | void FallbackAsset::onReload()
26 | {
27 | 	// Nothing to reload
28 | }
29 | 
30 | void FallbackAsset::renderInspectableUI()
31 | {
32 | 	IMComponents::label("Asset: " + path().filename().string(), EditorUI::getFonts().h2_bold);
33 | }
34 | 
35 | uint32_t FallbackAsset::icon() const
36 | {
37 | 	return IconPool::get("file");
38 | }


--------------------------------------------------------------------------------
/nuro-editor/assetsys/fallback_asset.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "editor_asset.h"
 4 | 
 5 | class FallbackAsset : public EditorAsset {
 6 | public:
 7 | 	struct Meta {
 8 | 		bool empty = true;
 9 | 	};
10 | 
11 | 	FallbackAsset();
12 | 	~FallbackAsset() override;
13 | 
14 | 	void onDefaultLoad(const FS::Path& metaPath) override;
15 | 	void onUnload() override;
16 | 	void onReload() override;
17 | 
18 | 	void renderInspectableUI() override;
19 | 
20 | 	uint32_t icon() const override;
21 | 
22 | private:
23 | 	Meta meta;
24 | };


--------------------------------------------------------------------------------
/nuro-editor/assetsys/font_asset.cpp:
--------------------------------------------------------------------------------
 1 | #include "font_asset.h"
 2 | 
 3 | #include <imgui.h>
 4 | 
 5 | #include <rendering/icons/icon_pool.h>
 6 | 
 7 | #include "../ui/components/im_components.h"
 8 | #include "../ui/windows/insight_panel_window.h"
 9 | 
10 | FontAsset::FontAsset() : meta(),
11 | handle(nullptr)
12 | {
13 | }
14 | 
15 | FontAsset::~FontAsset()
16 | {
17 | }
18 | 
19 | void FontAsset::onDefaultLoad(const FS::Path& metaPath)
20 | {
21 | 	AssetMeta::loadMeta<Meta>(&meta, metaPath);
22 | }
23 | 
24 | void FontAsset::onUnload()
25 | {
26 | 	//
27 | }
28 | 
29 | void FontAsset::onReload()
30 | {
31 | 	//
32 | }
33 | 
34 | void FontAsset::renderInspectableUI()
35 | {
36 | 	if (!handle) {
37 | 		IMComponents::label("Font is not loaded", EditorUI::getFonts().h3, IM_COL32(255, 255, 255, 255));
38 | 
39 | 		if (IMComponents::buttonBig("Load Font (Permanent)"))
40 | 			load();
41 | 
42 | 		return;
43 | 	}
44 | 
45 | 	std::string sampleText = "The quick brown fox jumps over the lazy dog.";
46 | 	IMComponents::label(sampleText, handle, IM_COL32(255, 255, 255, 255));
47 | }
48 | 
49 | uint32_t FontAsset::icon() const
50 | {
51 | 	return IconPool::get("font");
52 | }
53 | 
54 | ImFont* FontAsset::load()
55 | {
56 | 	FS::Path fontPath = path();
57 | 	if (!FS::hasExtension(fontPath, ".ttf") && !FS::hasExtension(fontPath, ".otf"))
58 | 		return nullptr;
59 | 
60 | 	// Load font here later (can't happen while rendering ui)
61 | }


--------------------------------------------------------------------------------
/nuro-editor/assetsys/font_asset.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | 
 5 | #include "editor_asset.h"
 6 | 
 7 | #include <utils/fsutil.h>
 8 | 
 9 | #include "../ui/editor_ui.h"
10 | 
11 | class ImFont;
12 | 
13 | class FontAsset : public EditorAsset {
14 | public:
15 | 	struct Meta {
16 | 		uint32_t size = EditorSizing::h2_FontSize;
17 | 	};
18 | 
19 | 	FontAsset();
20 | 	~FontAsset() override;
21 | 
22 | 	void onDefaultLoad(const FS::Path& metaPath) override;
23 | 	void onUnload() override;
24 | 	void onReload() override;
25 | 
26 | 	void renderInspectableUI() override;
27 | 
28 | 	uint32_t icon() const override;
29 | 
30 | private:
31 | 	Meta meta;
32 | 	ImFont* handle;
33 | 
34 | 	ImFont* load();
35 | };


--------------------------------------------------------------------------------
/nuro-editor/assetsys/texture_asset.cpp:
--------------------------------------------------------------------------------
 1 | #include "texture_asset.h"
 2 | 
 3 | #include <rendering/icons/icon_pool.h>
 4 | #include <rendering/texture/texture.h>
 5 | 
 6 | #include "../ui/windows/insight_panel_window.h"
 7 | 
 8 | TextureAsset::TextureAsset() : meta(),
 9 | textureResource(nullptr)
10 | {
11 | }
12 | 
13 | TextureAsset::~TextureAsset()
14 | {
15 | }
16 | 
17 | void TextureAsset::onDefaultLoad(const FS::Path& metaPath)
18 | {
19 | 	AssetMeta::loadMeta<Meta>(&meta, metaPath);
20 | 
21 | 	load(meta.type);
22 | }
23 | 
24 | void TextureAsset::onUnload()
25 | {
26 | 	if (!textureResource)
27 | 		return;
28 | 
29 | 	ApplicationContext::resourceManager().release(textureResource->resourceId());
30 | }
31 | 
32 | void TextureAsset::onReload()
33 | {
34 | 	// Perform resource hot reload here
35 | }
36 | 
37 | void TextureAsset::renderInspectableUI()
38 | {
39 | 	if (!textureResource) {
40 | 		IMComponents::label("Error: Texture is not available", EditorUI::getFonts().h2_bold, IM_COL32(255, 100, 100, 255));
41 | 		return;
42 | 	}
43 | 
44 | 	IMComponents::label(path().filename().string(), EditorUI::getFonts().h2_bold);
45 | 	ImGui::Separator();
46 | 	float contentX = ImGui::GetContentRegionAvail().x;
47 | 	ImGui::Image(textureResource->backendId(), ImVec2(contentX, contentX), ImVec2(0, 1), ImVec2(1, 0));
48 | }
49 | 
50 | uint32_t TextureAsset::icon() const
51 | {
52 | 	if (!textureResource)
53 | 		return IconPool::get("texture");
54 | 
55 | 	return textureResource->backendId();
56 | }
57 | 
58 | void TextureAsset::load(TextureType type)
59 | {
60 | 	std::string name = path().filename().string();
61 | 
62 | 	auto& resource = ApplicationContext::resourceManager();
63 | 	auto [id, texture] = resource.create<Texture>(name);
64 | 
65 | 	texture->setSource(type, path().string());
66 | 	resource.exec(texture->create());
67 | 
68 | 	textureResource = texture;
69 | }


--------------------------------------------------------------------------------
/nuro-editor/assetsys/texture_asset.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | 
 5 | #include "editor_asset.h"
 6 | 
 7 | #include <memory/resource_manager.h>
 8 | #include <rendering/texture/texture.h>
 9 | 
10 | enum class TextureType;
11 | 
12 | class TextureAsset : public EditorAsset {
13 | public:
14 | 	struct TextureSize {
15 | 		int width = 256;
16 | 		int height = 256;
17 | 	};
18 | 
19 | 	struct Meta {
20 | 		TextureType type = TextureType::IMAGE;
21 | 		TextureSize size;
22 | 	};
23 | 
24 | 	TextureAsset();
25 | 	~TextureAsset() override;
26 | 
27 | 	void onDefaultLoad(const FS::Path& metaPath) override;
28 | 	void onUnload() override;
29 | 	void onReload() override;
30 | 
31 | 	void renderInspectableUI() override;
32 | 
33 | 	uint32_t icon() const override;
34 | 
35 | private:
36 | 	Meta meta;
37 | 	ResourceRef<Texture> textureResource;
38 | 
39 | 	void load(TextureType type);
40 | };


--------------------------------------------------------------------------------
/nuro-editor/gizmos/component_gizmos.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <ecs/ecs_collection.h>
 4 | #include <rendering/gizmos/gizmos.h>
 5 | 
 6 | namespace ComponentGizmos
 7 | {
 8 | 
 9 | 	//
10 | 	// GENERAL
11 | 	//
12 | 
13 | 	// Renders icon gizmos of all components in register
14 | 	void drawSceneViewIcons(IMGizmo& gizmos, TransformComponent& cameraTransform);
15 | 
16 | 	// Renders gizmos of all components for specific entity
17 | 	void drawEntityGizmos(IMGizmo& gizmos, EntityContainer& entity);
18 | 
19 | 	//
20 | 	// COMPONENTS
21 | 	//
22 | 
23 | 	void drawCamera(IMGizmo& gizmos, TransformComponent& transform, CameraComponent& camera);
24 | 	void drawBoxCollider(IMGizmo& gizmos, TransformComponent& transform, BoxColliderComponent& boxCollider);
25 | 	void drawSphereCollider(IMGizmo& gizmos, TransformComponent& transform, SphereColliderComponent& sphereCollider);
26 | 	void drawPointLight(IMGizmo& gizmos, TransformComponent& transform, PointLightComponent& pointLight);
27 | 	void drawSpotlight(IMGizmo& gizmos, TransformComponent& transform, SpotlightComponent& spotlight);
28 | 	void drawAudioSource(IMGizmo& gizmos, TransformComponent& transform, AudioSourceComponent& audioSource);
29 | 
30 | };
31 | 


--------------------------------------------------------------------------------
/nuro-editor/gizmos/editor_gizmo_color.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glm/glm.hpp>
 4 | 
 5 | namespace EditorGizmoColor
 6 | {
 7 |     static constexpr glm::vec4 CAMERA = { 1.0f, 1.0f, 0.0f, 0.65f };
 8 |     static constexpr glm::vec4 COLLIDER = { 0.3f, 1.0f, 0.3f, 0.85f };
 9 |     static constexpr glm::vec4 AUDIO_SOURCE_DEFAULT = { 0.5f, 1.0f, 0.8f, 0.05f };
10 |     static constexpr glm::vec4 AUDIO_SOURCE_ACTIVE = { 0.2f, 1.0f, 1.0f, 0.05f };
11 | }


--------------------------------------------------------------------------------
/nuro-editor/imgui/README.md:
--------------------------------------------------------------------------------
1 | ## DEAR IMGUI SETUP
2 | 
3 | This is the setup of the dear imgui library including (modified) utilities.
4 | 
5 | - ImGui with docking ("imgui")
6 | - ImPlot ("implot")
7 | - Modified ImGuizmo clone ("ImGuizmo")
8 | - Text selection utility ("textselect")


--------------------------------------------------------------------------------
/nuro-editor/main.cpp:
--------------------------------------------------------------------------------
1 | #include "../runtime/runtime.h"
2 | 
3 | int main()
4 | {
5 | 	// RUN EDITOR
6 | 	return Runtime::START_LOOP();
7 | }


--------------------------------------------------------------------------------
/nuro-editor/pipelines/game_view_pipeline.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <vector>
  4 | 
  5 | #include <viewport/viewport.h>
  6 | #include <rendering/gizmos/gizmos.h>
  7 | #include <transform/transform_pass.h>
  8 | #include <rendering/passes/pre_pass.h>
  9 | #include <rendering/passes/ssao_pass.h>
 10 | #include <rendering/passes/forward_pass.h>
 11 | #include <rendering/velocitybuffer/velocity_buffer.h>
 12 | #include <rendering/postprocessing/post_processing.h>
 13 | #include <rendering/postprocessing/post_processing_pipeline.h>
 14 | 
 15 | class Skybox;
 16 | 
 17 | class GameViewPipeline
 18 | {
 19 | public:
 20 | 	GameViewPipeline();
 21 | 
 22 | 	// Create game view pipeline
 23 | 	void create();
 24 | 
 25 | 	// Destroy game view pipeline
 26 | 	void destroy();
 27 | 
 28 | 	// Renders game view
 29 | 	void render();
 30 | 
 31 | 	// Returns color output from latest render
 32 | 	uint32_t getOutput();
 33 | 
 34 | 	// Returns the viewport used
 35 | 	const Viewport& getViewport() const;
 36 | 
 37 | 	// Resizes the viewport used
 38 | 	void resizeViewport(float width, float height);
 39 | 
 40 | 	// Updates the msaa samples
 41 | 	void updateMsaaSamples(uint32_t msaaSamples);
 42 | 
 43 | 	// Returns the mutable post processing profile used
 44 | 	PostProcessing::Profile& getProfile();
 45 | 
 46 | 	// Sets given skybox to be linked
 47 | 	void linkSkybox(Skybox* skybox);
 48 | 
 49 | 	// Returns the currently linked skybox, may be nullptr if none is set
 50 | 	Skybox* getLinkedSkybox();
 51 | 
 52 | 	// The linked skybox will be drawn if this is set
 53 | 	bool drawSkybox;
 54 | 
 55 | 	// Sets given gizmo instance to be linked
 56 | 	void linkGizmos(IMGizmo* gizmos);
 57 | 
 58 | 	// Gizmos will be drawn if this is set
 59 | 	bool drawGizmos;
 60 | 
 61 | 	// Returns true if there was a camera render target available during the last render
 62 | 	bool getCameraAvailable();
 63 | 
 64 | 	// Returns the last ssao output
 65 | 	uint32_t getSSAOOutput() const;
 66 | 
 67 | 	// Returns the velocity buffers last output
 68 | 	uint32_t getVelocityOutput() const;
 69 | 
 70 | private:
 71 | 	// Create all passes
 72 | 	void createPasses();
 73 | 
 74 | 	// Destroy all passes
 75 | 	void destroyPasses();
 76 | 
 77 | 	//
 78 | 	// General members
 79 | 	//
 80 | 
 81 | 	Viewport viewport;
 82 | 	PostProcessing::Profile profile;
 83 | 	Skybox* skybox; // Optional skybox
 84 | 	IMGizmo* gizmos; // Optional gizmos
 85 | 
 86 | 	//
 87 | 	// Render settings
 88 | 	//
 89 | 
 90 | 	uint32_t msaaSamples;
 91 | 
 92 | 	//
 93 | 	// Passes
 94 | 	//
 95 | 
 96 | 	TransformPass transformPass;
 97 | 	PrePass prePass;
 98 | 	ForwardPass forwardPass;
 99 | 	SSAOPass ssaoPass;
100 | 	VelocityBuffer velocityBuffer;
101 | 	PostProcessingPipeline postProcessingPipeline;
102 | 
103 | 	//
104 | 	// States and outputs
105 | 	//
106 | 
107 | 	bool cameraAvailable;
108 | 
109 | 	uint32_t ssaoOutput;
110 | 	uint32_t velocityOutput;
111 | };


--------------------------------------------------------------------------------
/nuro-editor/pipelines/preview_pipeline.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <glm/glm.hpp>
 5 | 
 6 | #include <ecs/components.h>
 7 | #include <viewport/viewport.h>
 8 | 
 9 | class Model;
10 | class LitMaterial;
11 | 
12 | struct PreviewOutput {
13 | 	Viewport viewport;
14 | 	uint32_t texture = 0;
15 | 	bool resizePending = false;
16 | };
17 | 
18 | struct PreviewRenderInstruction {
19 | 	size_t outputIndex = 0;
20 | 	glm::vec4 backgroundColor = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
21 | 	Model* model = nullptr;
22 | 	LitMaterial* modelMaterial = nullptr;
23 | 	TransformComponent modelTransform;
24 | 	TransformComponent cameraTransform;
25 | };
26 | 
27 | class PreviewPipeline
28 | {
29 | public:
30 | 	PreviewPipeline();
31 | 
32 | 	// Creates the preview renderer frame
33 | 	void create();
34 | 
35 | 	// Destroys the preview renderer and all of the output textures connected with it
36 | 	void destroy();
37 | 
38 | 	// Renders all render instructions queued
39 | 	void render();
40 | 
41 | 	// Creates a new preview output and returns its index
42 | 	size_t createOutput();
43 | 
44 | 	// Returns preview output by given index 
45 | 	const PreviewOutput& getOutput(size_t index) const;
46 | 
47 | 	// Resizes an output by given index
48 | 	void resizeOutput(size_t index, float width, float height);
49 | 
50 | 	// Adds the given render instruction to the rendering queue
51 | 	void addRenderInstruction(PreviewRenderInstruction instruction);
52 | 
53 | private:
54 | 	uint32_t fbo;
55 | 	uint32_t rbo;
56 | 	std::vector<PreviewOutput> outputs;
57 | 	std::vector<PreviewRenderInstruction> renderInstructions;
58 | };


--------------------------------------------------------------------------------
/nuro-editor/pipelines/scene_view_forward_pass.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <viewport/viewport.h>
 8 | #include <ecs/ecs_collection.h>
 9 | #include <rendering/gizmos/imgizmo.h>
10 | 
11 | class Skybox;
12 | class IMaterial;
13 | class UnlitMaterial;
14 | 
15 | class SceneViewForwardPass
16 | {
17 | public:
18 | 	explicit SceneViewForwardPass(const Viewport& viewport);
19 | 
20 | 	void create(uint32_t msaaSamples); // Creates forward pass
21 | 	void destroy(); // Destroys forward pass
22 | 
23 | 	// Scene view forward passes all entity render targets and returns color output
24 | 	uint32_t render(const glm::mat4& view, const glm::mat4& projection, const glm::mat4& viewProjection, const Camera& camera, const std::vector<EntityContainer*>& selectedEntities);
25 | 
26 | 	void linkSkybox(Skybox* skybox);
27 | 	bool drawSkybox; // Draw skybox in scene view
28 | 
29 | 	void linkGizmos(IMGizmo* gizmos);
30 | 	bool drawGizmos; // Draw gizmos in scene view
31 | 
32 | 	bool wireframe; // Wireframe rendering mode
33 | 	glm::vec4 clearColor; // Clear color for forward pass
34 | private:
35 | 	const Viewport& viewport; // Viewport forward pass instance is linked to
36 | 
37 | 	Skybox* skybox; // Skybox that will be rendered during forward pass (optional)
38 | 	IMGizmo* gizmos; // Gizmo instance that will be rendered during forward pass (optional)
39 | 
40 | 	uint32_t outputFbo;	 // Output framebuffer
41 | 	uint32_t outputColor; // Output color
42 | 
43 | 	uint32_t multisampledFbo; // Anti-aliasing framebuffer
44 | 	uint32_t multisampledRbo; // Anti-aliasing renderbuffer
45 | 	uint32_t multisampledColorBuffer; // Anti-aliasing colorbuffer
46 | 
47 | 	UnlitMaterial* selectionMaterial; // Material for selection outline
48 | 
49 | 	// Default scene view clearing color rgb values
50 | 	static constexpr float defaultClearColor[3] = { 0.015f, 0.015f, 0.015f };
51 | 
52 | 	void renderMesh(TransformComponent& transform, MeshRendererComponent& renderer); // Renders a given entities mesh
53 | 	void renderMeshes(const std::vector<EntityContainer*>& skippedEntities); // Renders all meshes
54 | 	void renderSelectedEntity(EntityContainer* entity, const glm::mat4& viewProjection, const Camera& camera); // Renders the selected entity with an outline
55 | };


--------------------------------------------------------------------------------
/nuro-editor/project/project_assets.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <unordered_map>
 5 | 
 6 | #include <utils/fsutil.h>
 7 | 
 8 | #include "../assetsys/editor_asset.h"
 9 | 
10 | using AssetRef = std::shared_ptr<EditorAsset>;
11 | 
12 | class ProjectAssets {
13 | public:
14 | 	ProjectAssets();
15 | 
16 | 	// Loads an editor asset and returns its session id
17 | 	AssetSID load(const FS::Path& path);
18 | 
19 | 	// Removes an editor asset if existing
20 | 	void remove(AssetSID id);
21 | 
22 | 	// Reloads an asset, returns success
23 | 	bool reload(AssetSID id);
24 | 
25 | 	// Returns an editor asset reference by its session id, nullptr if none
26 | 	AssetRef get(AssetSID id) const;
27 | 
28 | 	// Returns an assets session id by its guid
29 | 	AssetSID resolveGUID(AssetGUID guid);
30 | 
31 | 	// Updates an existing assets io location
32 | 	void updateLocation(AssetSID id, FS::Path path);
33 | 
34 | private:
35 | 	// Counter for asset session ids
36 | 	uint32_t sidCounter;
37 | 
38 | 	// Returns a new session id
39 | 	AssetSID createSID();
40 | 
41 | 	// Registry of all assets by their session id
42 | 	std::unordered_map<AssetSID, AssetRef> assets;
43 | 
44 | 	// Registry of all asset session ids by their guid
45 | 	std::unordered_map<AssetGUID, AssetSID> assetSIDs;
46 | 
47 | };


--------------------------------------------------------------------------------
/nuro-editor/project/project_manager.cpp:
--------------------------------------------------------------------------------
 1 | #include "project_manager.h"
 2 | 
 3 | #include <fstream>
 4 | 
 5 | #include <utils/console.h>
 6 | 
 7 | ProjectManager::ProjectManager() : _project(),
 8 | _observer(),
 9 | _assets() 
10 | {
11 | }
12 | 
13 | void ProjectManager::pollEvents()
14 | {
15 | 	_observer.pollEvents();
16 | }
17 | 
18 | bool ProjectManager::load(const FS::Path& directory)
19 | {
20 | 	if (!FS::exists(directory) || !FS::isDirectory(directory)) {
21 | 		Console::out::error("Project", "Project path is invalid.", "Provided path was '" + directory.string() + "'");
22 | 		return false;
23 | 	}
24 | 
25 | 	// Set project path
26 | 	_project.path = directory;
27 | 
28 | 	// Ensure project configuration is valid
29 | 	if (!ensureConfig()) 
30 | 		return false;
31 | 
32 | 	// Start observing project
33 | 	_observer.setTarget(_project.path);
34 | 
35 | 	return true;
36 | }
37 | 
38 | const Project& ProjectManager::project() const
39 | {
40 | 	return _project;
41 | }
42 | 
43 | ProjectObserver& ProjectManager::observer()
44 | {
45 | 	return _observer;
46 | }
47 | 
48 | ProjectAssets& ProjectManager::assets()
49 | {
50 | 	return _assets;
51 | }
52 | 
53 | FS::Path ProjectManager::abs(const FS::Path& path)
54 | {
55 | 	return _project.path / path;
56 | }
57 | 
58 | bool ProjectManager::ensureConfig()
59 | {
60 | 	// Default configuration path
61 | 	FS::Path configPath = FS::Path(_project.path) / ".project";
62 | 
63 | 	// Touch configuration file
64 | 	if (FS::touch(configPath)) 
65 | 		return true;
66 | 
67 | 	Console::out::error("Project", "Couldn't locate or create project configuration.", "Tried to create it at '" + configPath.string() + "'");
68 | 	return false;
69 | }


--------------------------------------------------------------------------------
/nuro-editor/project/project_manager.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <nlohmann/json.hpp>
 5 | 
 6 | #include <utils/fsutil.h>
 7 | 
 8 | #include "../project/project_observer.h"
 9 | #include "../project/project_assets.h"
10 | 
11 | struct Project {
12 | 	// Root path of the project
13 | 	FS::Path path;
14 | 
15 | 	// Configuration of the project
16 | 	struct Config {
17 | 		std::string name = "Unnamed Project*";
18 | 	} config;
19 | };
20 | 
21 | class ProjectManager
22 | {
23 | public:
24 | 	ProjectManager();
25 | 
26 | 	// Dispatches any project related events
27 | 	void pollEvents();
28 | 
29 | 	// Loads the project located in the given directory
30 | 	bool load(const FS::Path& directory);
31 | 
32 | 	// Returns the currently loaded project
33 | 	const Project& project() const;
34 | 
35 | 	// Returns the project observer
36 | 	ProjectObserver& observer();
37 | 
38 | 	// Returns the project assets
39 | 	ProjectAssets& assets();
40 | 
41 | 	// Converts a relative path within the current project to an absolute path
42 | 	FS::Path abs(const FS::Path& path);
43 | 
44 | private:
45 | 	// Ensures configuration of the current project exists, returns false if creating failed
46 | 	bool ensureConfig();
47 | 
48 | 	Project _project;
49 | 	ProjectObserver _observer;
50 | 	ProjectAssets _assets;
51 | };


--------------------------------------------------------------------------------
/nuro-editor/reflection/asset_registry.cpp:
--------------------------------------------------------------------------------
 1 | #include "asset_registry.h"
 2 | 
 3 | #include <string>
 4 | #include <unordered_map>
 5 | 
 6 | #include "../assetsys/font_asset.h"
 7 | #include "../assetsys/editor_asset.h"
 8 | #include "../assetsys/texture_asset.h"
 9 | #include "../assetsys/fallback_asset.h"
10 | #include "../ui/inspectables/inspectable.h"
11 | #include "../ui/windows/insight_panel_window.h"
12 | #include "../ui/inspectables/asset_inspectable.h"
13 | 
14 | namespace AssetRegistry {
15 | 
16 |     // Asset info for fallback asset
17 |     std::shared_ptr<AssetInfo> fallbackAsset;
18 | 
19 |     // Global registry for all assets by extension
20 |     std::unordered_map<std::string, std::shared_ptr<AssetInfo>> gAssetRegistry;
21 | 
22 |     template <typename InstanceType>
23 |     std::shared_ptr<AssetInfo> createAssetInfo(AssetType type) {
24 |         static_assert(std::is_base_of<EditorAsset, InstanceType>::value, "Only classes that derive from EditorAsset are valid for asset registration");
25 | 
26 |         // Create asset info instance dynamically
27 |         auto assetInfo = std::make_shared<AssetInfo>();
28 |         assetInfo->type = type;
29 |         assetInfo->createInstance = []() { return std::make_shared<InstanceType>(); };
30 |         assetInfo->inspect = [](AssetSID id) { InsightPanelWindow::inspect<AssetInspectable>(id); };
31 | 
32 |         return assetInfo;
33 |     }
34 | 
35 |     // Registers an asset onto the registry
36 |     template <typename InstanceType>
37 |     void registerAsset(AssetType type, std::vector<std::string> extensions){
38 |         // Create asset info
39 |         auto assetInfo = createAssetInfo<InstanceType>(type);
40 | 
41 |         // Register asset info reference by extensions
42 |         for (const std::string& extension : extensions) {
43 |             gAssetRegistry[extension] = assetInfo;
44 |         }
45 |     }
46 | 
47 |     const std::unordered_map<std::string, std::shared_ptr<AssetInfo>>& get()
48 |     {
49 |         return gAssetRegistry;
50 |     }
51 | 
52 |     std::shared_ptr<AssetInfo> fetchByPath(const FS::Path& path)
53 |     {
54 |         // Extract file extension from path
55 |         std::string extension = path.extension().string();
56 |         if (!extension.empty() && extension[0] == '.')
57 |             extension.erase(0, 1);
58 | 
59 |         // Find asset info by extension in registry
60 |         auto it = gAssetRegistry.find(extension);
61 |         if (it == gAssetRegistry.end()) {
62 |             if (extension != "meta")
63 |                 return fallbackAsset;
64 |             return nullptr;
65 |         }
66 |         return it->second;
67 |     }
68 | 
69 |     void create()
70 |     {
71 |         fallbackAsset = createAssetInfo<FallbackAsset>(AssetType::FALLBACK);
72 | 
73 |         registerAsset<TextureAsset>(
74 |             AssetType::TEXTURE,
75 |             { "jpg", "jpeg", "png", "bmp", "tga", "psd", "gif", "hdr", "pic", "ppm", "pgm" }
76 |         );
77 | 
78 |         registerAsset<FontAsset>(
79 |             AssetType::FONT,
80 |             { "ttf", "otf" }
81 |         );
82 |     }
83 | 
84 | }


--------------------------------------------------------------------------------
/nuro-editor/reflection/asset_registry.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <memory>
 5 | #include <vector>
 6 | #include <optional>
 7 | #include <functional>
 8 | 
 9 | #include <utils/fsutil.h>
10 | 
11 | #include "../assetsys/editor_asset.h"
12 | 
13 | struct AssetInfo {
14 | 
15 | 	using AssetRef = std::shared_ptr<EditorAsset>;
16 | 	using AssetID = uint32_t;
17 | 
18 | 	// Type of the asset
19 | 	AssetType type = AssetType::FALLBACK;
20 | 
21 | 	// Function to create an asset instance from this asset
22 | 	std::function<AssetRef()> createInstance;
23 | 
24 | 	// Function to inspect this asset type by an assets id
25 | 	std::function<void(AssetID)> inspect;
26 | 
27 | };
28 | 
29 | namespace AssetRegistry {
30 | 
31 | 	// Returns asset registry (key represents file extension)
32 | 	const std::unordered_map<std::string, std::shared_ptr<AssetInfo>>& get();
33 | 
34 | 	// Fetches asset info by an asset path, nullptr if none
35 | 	std::shared_ptr<AssetInfo> fetchByPath(const FS::Path& path);
36 | 
37 | 	// Creates global asset registry
38 | 	void create();
39 | 
40 | }


--------------------------------------------------------------------------------
/nuro-editor/reflection/component_registry.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | #include <optional>
 6 | #include <functional>
 7 | #include <unordered_map>
 8 | 
 9 | #include <ecs/ecs_collection.h>
10 | #include <rendering/gizmos/imgizmo.h>
11 | 
12 | // Reflection type for an editor compatible ecs component
13 | struct ComponentInfo {
14 | 
15 |     // Name of component
16 |     std::string name;
17 | 
18 |     // Editor component icon identifier
19 |     std::string icon;
20 | 
21 |     // Function returning if component is owned by an entity
22 |     std::function<bool(Entity)> has;
23 | 
24 |     // Function adding component to an entity
25 |     std::function<void(Entity)> add;
26 | 
27 |     // Function drawing insight panel component inspectable for an entity if that entity has the component
28 |     std::function<void(Entity)> tryDrawInspectable;
29 | 
30 |     // Function drawing component gizmo for an entity if component has gizmo and entity has the component
31 |     std::function<void(Entity, IMGizmo&)> tryDrawGizmo;
32 | 
33 |     // Function drawing scene view icons for all instances of component if it has a scene view icon (taking in gizmo instance and transform of camera rendering)
34 |     std::function<void(IMGizmo&, TransformComponent&)> tryDrawSceneIcons;
35 | };
36 | 
37 | namespace ComponentRegistry
38 | {
39 | 
40 |     // Creates global editor component registry
41 |     void create();
42 | 
43 |     // Returns editor component registry
44 |     const std::unordered_map<std::string, ComponentInfo>& get();
45 | 
46 |     // Returns ordered keys of editor component registry
47 |     const std::vector<std::string>& keysOrdered();
48 | 
49 | };


--------------------------------------------------------------------------------
/nuro-editor/runtime/runtime.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <engine.h>
 4 | #include <rendering/gizmos/imgizmo.h>
 5 | 
 6 | #include "../project/project_manager.h"
 7 | #include "../pipelines/game_view_pipeline.h"
 8 | #include "../pipelines/scene_view_pipeline.h"
 9 | #include "../pipelines/preview_pipeline.h"
10 | 
11 | class ShadowDisk;
12 | class ShadowMap;
13 | 
14 | class Model;
15 | class LitMaterial;
16 | 
17 | enum class GameState {
18 | 	GAME_SLEEPING,
19 | 	GAME_LOADING,
20 | 	GAME_RUNNING,
21 | 	GAME_PAUSED,
22 | };
23 | 
24 | namespace Runtime
25 | {
26 | 	//
27 | 	// Base functions
28 | 	//
29 | 
30 | 	int START_LOOP();
31 | 	int TERMINATE();
32 | 
33 | 	//
34 | 	// Project
35 | 	//
36 | 
37 | 	ProjectManager& projectManager();
38 | 
39 | 	//
40 | 	// Game functions
41 | 	//
42 | 
43 | 	void startGame();
44 | 	void stopGame();
45 | 	void pauseGame();
46 | 	void continueGame();
47 | 
48 | 	GameState gameState();
49 | 
50 | 	//
51 | 	// Pipelines getters
52 | 	//
53 | 
54 | 	SceneViewPipeline& sceneViewPipeline();
55 | 	GameViewPipeline& gameViewPipeline();
56 | 	PreviewPipeline& previewPipeline();
57 | 
58 | 	//
59 | 	// Gizmo getters
60 | 	//
61 | 
62 | 	IMGizmo& sceneGizmos();
63 | 
64 | 	//
65 | 	// Shadow getters
66 | 	//
67 | 
68 | 	ShadowDisk* mainShadowDisk();
69 | 	ShadowMap* mainShadowMap();
70 | };


--------------------------------------------------------------------------------
/nuro-editor/testing/game_logic.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | void gameSetup();
4 | void gameAwake();
5 | void gameQuit();
6 | void gameUpdate();


--------------------------------------------------------------------------------
/nuro-editor/ui/components/inspectable_components.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <ecs/ecs_collection.h>
 4 | #include <rendering/postprocessing/post_processing.h>
 5 | 
 6 | #include "../reflection/component_registry.h"
 7 | 
 8 | namespace InspectableComponents
 9 | {
10 | 
11 | 	//
12 | 	// INSPECTABLE ECS COMPONENTS
13 | 	//
14 | 
15 | 	void drawTransform(Entity entity, TransformComponent& transform);
16 | 	void drawMeshRenderer(Entity entity, MeshRendererComponent& meshRenderer);
17 | 	void drawCamera(Entity entity, CameraComponent& camera);
18 | 	void drawDirectionalLight(Entity entity, DirectionalLightComponent& directionalLight);
19 | 	void drawPointLight(Entity entity, PointLightComponent& pointLight);
20 | 	void drawSpotlight(Entity entity, SpotlightComponent& spotlight);
21 | 	void drawVelocity(Entity entity, VelocityBlurComponent& velocity);
22 | 	void drawBoxCollider(Entity entity, BoxColliderComponent& boxCollider);
23 | 	void drawSphereCollider(Entity entity, SphereColliderComponent& sphereCollider);
24 | 	void drawRigidbody(Entity entity, RigidbodyComponent& rigidbody);
25 | 	void drawAudioListener(Entity entity, AudioListenerComponent& audioListener);
26 | 	void drawAudioSource(Entity entity, AudioSourceComponent& audioSource);
27 | 
28 | 	//
29 | 	// INSPECTABLE POST PROCESSING COMPONENTS
30 | 	//
31 | 
32 | 	void drawColor(PostProcessing::Color& color);
33 | 	void drawMotionBlur(PostProcessing::MotionBlur& motionBlur);
34 | 	void drawBloom(PostProcessing::Bloom& bloom);
35 | 	void drawChromaticAberration(PostProcessing::ChromaticAberration& chromaticAberration);
36 | 	void drawVignette(PostProcessing::Vignette& vignette);
37 | 	void drawAmbientOcclusion(PostProcessing::AmbientOcclusion& ambientOcclusion);
38 | 
39 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/context_menu/context_menu.cpp:
--------------------------------------------------------------------------------
 1 | #include "context_menu.h"
 2 | 
 3 | #include <imgui.h>
 4 | 
 5 | #include "../ui/editor_ui.h"
 6 | 
 7 | namespace ContextMenu {
 8 | 
 9 | 	ImVec4 _backgroundColor = ImVec4(0.2f, 0.2f, 0.25f, 0.9f);
10 | 	ImVec4 _textColor = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
11 | 	ImVec4 _hoverColor = ImVec4(0.1f, 0.1f, 0.15f, 1.0f);
12 | 	ImU32 _outlineColor = EditorColor::selection;
13 | 
14 | 	void _space() {
15 | 		ImGui::Dummy(ImVec2(0.0f, 0.1f));
16 | 	}
17 | 
18 | 	bool begin()
19 | 	{
20 | 		// Custom context menu colors
21 | 		ImGui::PushStyleColor(ImGuiCol_PopupBg, _backgroundColor);
22 | 		ImGui::PushStyleColor(ImGuiCol_Text, _textColor);
23 | 		ImGui::PushStyleColor(ImGuiCol_HeaderHovered, _hoverColor);
24 | 		ImGui::PushStyleColor(ImGuiCol_Border, _outlineColor);
25 | 
26 | 		std::string id = EditorUI::generateIdString();
27 | 		return ImGui::BeginPopupContextWindow(id.c_str(), ImGuiPopupFlags_MouseButtonRight);
28 | 	}
29 | 
30 | 	void end()
31 | 	{
32 | 		ImGui::EndPopup();
33 | 	}
34 | 
35 | 	void pop()
36 | 	{
37 | 		ImGui::PopStyleColor(4);
38 | 	}
39 | 
40 | 	bool item(const char* icon, std::string title)
41 | 	{
42 | 		_space();
43 | 		std::string text = std::string(icon) + "     " + title;
44 | 		return ImGui::MenuItem(text.c_str());
45 | 	}
46 | 
47 | 	bool itemLight(std::string title)
48 | 	{
49 | 		return ImGui::MenuItem(title.c_str());
50 | 	}
51 | 
52 | 	bool menu(const char* icon, std::string title)
53 | 	{
54 | 		_space();
55 | 		std::string text = std::string(icon) + "     " + title;
56 | 		return ImGui::BeginMenu(text.c_str());
57 | 	}
58 | 
59 | 	void endMenu()
60 | 	{
61 | 		ImGui::EndMenu();
62 | 	}
63 | 
64 | 	void seperator()
65 | 	{
66 | 		_space();
67 | 		ImGui::Separator();
68 | 	}
69 | 
70 | }


--------------------------------------------------------------------------------
/nuro-editor/ui/context_menu/context_menu.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | 
 5 | namespace ContextMenu
 6 | {
 7 | 
 8 | 	// Begins a new context menu
 9 | 	bool begin();
10 | 
11 | 	// Ends the current context menu
12 | 	void end();
13 | 
14 | 	// Pops context menu variations
15 | 	void pop();
16 | 
17 | 	// Creates a new item within the current context menu
18 | 	bool item(const char* icon, std::string title);
19 | 	
20 | 	// Creates a new item without icon and margin within the current context menu
21 | 	bool itemLight(std::string title);
22 | 
23 | 	// Creates a new menu within the current context menu
24 | 	bool menu(const char* icon, std::string title);
25 | 
26 | 	// Ends the current menu
27 | 	void endMenu();
28 | 
29 | 	// Draws a seperator
30 | 	void seperator();
31 | 
32 | };
33 | 
34 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/dynamic_drawing/draw_alignments.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | enum class TextAlign {
 4 | 	LEFT,
 5 | 	CENTER,
 6 | 	RIGHT
 7 | };
 8 | 
 9 | enum class Horizontal {
10 | 	FREE,
11 | 	LEFT,
12 | 	CENTER,
13 | 	RIGHT
14 | };
15 | 
16 | enum class Vertical {
17 | 	FREE,
18 | 	TOP,
19 | 	CENTER,
20 | 	BOTTOM
21 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/dynamic_drawing/dynamic_text.cpp:
--------------------------------------------------------------------------------
 1 | #include "dynamic_text.h"
 2 | 
 3 | DynamicText::DynamicText(ImFont* font) : font(font)
 4 | {
 5 | }
 6 | 
 7 | void DynamicText::draw(ImDrawList* drawList)
 8 | {
 9 | 	// Calculate draw position with text position and padding
10 | 	ImVec2 drawPosition = position + padding;
11 | 
12 | 	// Add to draw list
13 | 	drawList->AddText(font, font->FontSize, drawPosition, color, text.c_str());
14 | }
15 | 
16 | ImVec2 DynamicText::getSize() const
17 | {
18 | 	// Get base size from text displayed
19 | 	ImVec2 size = font->CalcTextSizeA(font->FontSize, FLT_MAX, -1.0f, text.c_str());
20 | 	
21 | 	// Add total padding to size
22 | 	size += padding * 2;
23 | 
24 | 	// Return size
25 | 	return size;
26 | }


--------------------------------------------------------------------------------
/nuro-editor/ui/dynamic_drawing/dynamic_text.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define IMGUI_DEFINE_MATH_OPERATORS
 4 | #include <imgui.h>
 5 | #include <cstdint>
 6 | #include <string>
 7 | 
 8 | #include "draw_alignments.h"
 9 | 
10 | class DynamicText
11 | {
12 | public:
13 | 	DynamicText(ImFont* font);
14 | 
15 | 	//
16 | 	// PROPERTIES
17 | 	//
18 | 
19 | 	// Pointer to font text is using
20 | 	ImFont* font;
21 | 
22 | 	// Text value of element
23 | 	std::string text;
24 | 
25 | 	// Position of text (may be controlled by parent)
26 | 	ImVec2 position = ImVec2(0.0f, 0.0f);
27 | 
28 | 	// Color of text
29 | 	ImU32 color = IM_COL32(0, 0, 0, 255);
30 | 
31 | 	// Horizontal and vertical padding of text
32 | 	ImVec2 padding = ImVec2(0.0f, 0.0f);
33 | 
34 | 	// Text alignment within parent component if it has any
35 | 	TextAlign alignment = TextAlign::LEFT;
36 | 
37 | 	//
38 | 	// VIRTUAL CONTENT ELEMENT FUNCTIONS
39 | 	//
40 | 
41 | 	// Draws the ui text
42 | 	void draw(ImDrawList* drawList);
43 | 
44 | 	// Returns the absolute size of the text in px
45 | 	ImVec2 getSize() const;
46 | };
47 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/footer/footer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <glm/glm.hpp>
 5 | #define IMGUI_DEFINE_MATH_OPERATORS
 6 | #include <imgui.h>
 7 | #include <tuple>
 8 | #include <array>
 9 | 
10 | struct FooterStyle {
11 | 
12 | 	float height = 36.0f;
13 | 	ImU32 backgroundColor = IM_COL32(30, 30, 30, 255);
14 | 	ImVec2 padding = ImVec2(22.0f, 0.0f);
15 | 
16 | 	ImFont* primaryFont = nullptr;
17 | 	ImFont* secondaryFont = nullptr;
18 | 
19 | 	ImU32 primaryTextColor = IM_COL32(255, 255, 255, 255);
20 | 	ImU32 secondaryTextColor = IM_COL32(180, 180, 180, 255);
21 | 
22 | };
23 | 
24 | class Footer
25 | {
26 | public:
27 | 	Footer();
28 | 
29 | 	// Renders the footer in the given viewport
30 | 	void render(const ImGuiViewport& viewport);
31 | 
32 | 	// Returns the style configuration of the footer
33 | 	FooterStyle& getStyle();
34 | 
35 | 	// Current style configuration
36 | 	FooterStyle style;
37 | 
38 | private:
39 | 	// Renders the content of the footer
40 | 	void renderContent(ImDrawList& drawList);
41 | 
42 | private:
43 | 	ImVec2 footerPosition;
44 | 	ImVec2 footerSize;
45 | 
46 | private:
47 | 	// Footer virtual window flags
48 | 	static constexpr ImGuiWindowFlags flags = 
49 | 		ImGuiWindowFlags_NoDecoration | 
50 | 		ImGuiWindowFlags_NoMove | 
51 | 		ImGuiWindowFlags_NoBackground | 
52 | 		ImGuiWindowFlags_NoScrollWithMouse;
53 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/inspectables/asset_inspectable.cpp:
--------------------------------------------------------------------------------
 1 | #include "asset_inspectable.h"
 2 | 
 3 | #include "../../runtime/runtime.h"
 4 | 
 5 | AssetInspectable::AssetInspectable(AssetSID assetId) : assetId(assetId)
 6 | {
 7 | }
 8 | 
 9 | void AssetInspectable::renderStaticContent(ImDrawList& drawList)
10 | {
11 | 	if (auto asset = Runtime::projectManager().assets().get(assetId))
12 | 		asset->renderInspectableUI();
13 | }
14 | 
15 | void AssetInspectable::renderDynamicContent(ImDrawList& drawList)
16 | {
17 | }


--------------------------------------------------------------------------------
/nuro-editor/ui/inspectables/asset_inspectable.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "inspectable.h"
 4 | 
 5 | #include "../assetsys/editor_asset.h"
 6 | 
 7 | class AssetInspectable : public Inspectable
 8 | {
 9 | public:
10 | 	AssetInspectable(AssetSID assetId);
11 | 
12 | 	void renderStaticContent(ImDrawList& drawList) override;
13 | 	void renderDynamicContent(ImDrawList& drawList) override;
14 | private:
15 | 	AssetSID assetId;
16 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/inspectables/entity_inspectable.cpp:
--------------------------------------------------------------------------------
 1 | #include "entity_inspectable.h"
 2 | 
 3 | #include <glm/glm.hpp>
 4 | 
 5 | #include "../ui/editor_ui.h"
 6 | #include <ecs/components.h>
 7 | #include "../ui/windows/registry_window.h"
 8 | #include "../ui/components/im_components.h"
 9 | #include "../ui/search/search_popup.h"
10 | #include "../ui/windows/insight_panel_window.h"
11 | #include "../reflection/component_registry.h"
12 | #include "../ui/components/inspectable_components.h"
13 | 
14 | EntityInspectable::EntityInspectable(HierarchyItem& item) : item(item)
15 | {
16 | }
17 | 
18 | void EntityInspectable::renderStaticContent(ImDrawList& drawList)
19 | {
20 | 	IMComponents::label(item.entity.name(), EditorUI::getFonts().h3_bold);
21 | 	ImGui::Dummy(ImVec2(0.0f, 3.0f));
22 | 
23 | 	ImVec2 searchPosition = ImGui::GetCursorScreenPos() + ImVec2(0.0f, 38.0f);
24 | 	if (IMComponents::buttonBig("Add Component")) SearchPopup::searchComponents(searchPosition, item.entity.handle());
25 | }
26 | 
27 | void EntityInspectable::renderDynamicContent(ImDrawList& drawList)
28 | {
29 | 	const auto& components = ComponentRegistry::get();
30 | 	const auto& keysOrdered = ComponentRegistry::keysOrdered();
31 | 
32 | 	for (const auto& key : keysOrdered) {
33 | 		components.at(key).tryDrawInspectable(item.entity.handle());
34 | 	}
35 | }


--------------------------------------------------------------------------------
/nuro-editor/ui/inspectables/entity_inspectable.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional>
 4 | 
 5 | #include "inspectable.h"
 6 | 
 7 | #include <ecs/ecs_collection.h>
 8 | #include "../ui/windows/registry_window.h"
 9 | 
10 | class EntityInspectable : public Inspectable
11 | {
12 | public:
13 | 	EntityInspectable(HierarchyItem& item);
14 | 
15 | 	void renderStaticContent(ImDrawList& drawList) override;
16 | 	void renderDynamicContent(ImDrawList& drawList) override;
17 | private:
18 | 	// Currently inspected hierarchy item
19 | 	HierarchyItem& item;
20 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/inspectables/inspectable.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define IMGUI_DEFINE_MATH_OPERATORS
 4 | #include <imgui.h>
 5 | #include <string>
 6 | 
 7 | class Inspectable
 8 | {
 9 | public:
10 | 	virtual void renderStaticContent(ImDrawList& drawList) = 0;
11 | 	virtual void renderDynamicContent(ImDrawList& drawList) = 0;
12 | };
13 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/inspectables/welcome_inspectable.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <string_view>
 5 | #include <textselect.hpp>
 6 | 
 7 | #include "inspectable.h"
 8 | 
 9 | #include "../ui/windows/console_window.h"
10 | 
11 | class WelcomeInspectable : public Inspectable
12 | {
13 | public:
14 | 	WelcomeInspectable();
15 | 
16 | 	void renderStaticContent(ImDrawList& drawList) override;
17 | 	void renderDynamicContent(ImDrawList& drawList) override;
18 | 
19 | private:
20 | 	// Snapshot of the engines console logs at instantiation of this welcome inspectable
21 | 	std::vector<ConsoleLog> consoleSnapshot;
22 | 
23 | 	// Set if game was played through welcome inspectable already
24 | 	bool playedGame;
25 | 
26 | 	//
27 | 	// Text selection
28 | 	//
29 | 
30 | 	std::vector<std::string_view> loggedIssues;
31 | 	std::string_view logLineAt(size_t i);
32 | 	size_t nLogs();
33 | 	TextSelect logSelect;
34 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/search/search_popup.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define IMGUI_DEFINE_MATH_OPERATORS
 4 | #include <imgui.h>
 5 | 
 6 | #include <ecs/ecs.h>
 7 | 
 8 | namespace SearchPopup
 9 | {
10 | 	// Renders the current search popup if any is opened
11 | 	void render();
12 | 
13 | 	// Closes the search popup if any is opened
14 | 	void close();
15 | 
16 | 	// Opens a popup to search for ecs components
17 | 	void searchComponents(ImVec2 position, Entity target);
18 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/utils/ui_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define IMGUI_DEFINE_MATH_OPERATORS
 4 | #include <imgui.h>
 5 | #include <string>
 6 | #include <glm/glm.hpp>
 7 | 
 8 | namespace UIUtils
 9 | {
10 | 
11 | 	// Lightens color by given amount
12 | 	ImU32 lighten(ImU32 color, float amount);
13 | 
14 | 	// Darkens color by given amount
15 | 	ImU32 darken(ImU32 color, float amount);
16 | 
17 | 	// Lerps between given colors
18 | 	ImVec4 lerpColors(const ImVec4& a, const ImVec4& b, float t);
19 | 
20 | 	// Returns the relative scroll value of current ui child rendering
21 | 	float getChildScrollValue();
22 | 
23 | 	// Keeps the cursor in the given boundaries, returns the new cursor position and sets if the cursor was positioned by method
24 | 	glm::vec2 keepCursorInBounds(glm::vec4 bounds, bool& cursorMoved, float offset = 40.0f);
25 | 
26 | 	// Calculates the size and offset an image can have to be displayed at the biggest size possible centered with the given aspect ratio
27 | 	void calculateAspectFitting(float aspectRatio, ImVec2& size, ImVec2& offset);
28 | 
29 | 	// Returns title for window with adjusted spacing
30 | 	std::string windowTitle(const char* title);
31 | 
32 | 	// Returns if the current window is focused
33 | 	bool windowFocused();
34 | 
35 | 	// Returns if the current window is hovered
36 | 	bool windowHovered();
37 | 
38 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/asset_browser_window.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonkwl/nuro/60039f25f36d71950eeb53e230cc72495f037d9d/nuro-editor/ui/windows/asset_browser_window.cpp


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/asset_browser_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | #include <memory>
 6 | #include <unordered_map>
 7 | 
 8 | #include "editor_window.h"
 9 | #include "../project/project_assets.h"
10 | #include "../project/project_observer.h"
11 | 
12 | using NodeRef = std::shared_ptr<ProjectObserver::IONode>;
13 | using FileRef = std::shared_ptr<ProjectObserver::File>;
14 | using FolderRef = std::shared_ptr<ProjectObserver::Folder>;
15 | 
16 | class AssetBrowserWindow : public EditorWindow
17 | {
18 | public:
19 | 	AssetBrowserWindow();
20 | 
21 | 	void render() override;
22 | 
23 | 	// Selects a folder by its io node id
24 | 	static void selectFolder(uint32_t folderId);
25 | 
26 | 	// Unselects the currently selected folder if any
27 | 	static void unselectFolder();
28 | 
29 | private:
30 | 	struct NodeUIData {
31 | 		std::string text;
32 | 		ImFont* font;
33 | 		ImVec2 padding;
34 | 		ImVec2 iconSize;
35 | 		ImVec2 textSize;
36 | 		ImVec2 size;
37 | 
38 | 		explicit NodeUIData(std::string text, ImFont* font, ImVec2 padding, ImVec2 iconSize, ImVec2 textSize, ImVec2 size) :
39 | 			text(text), font(font), padding(padding), iconSize(iconSize), textSize(textSize), size(size) 
40 | 		{
41 | 		};
42 | 
43 | 		static NodeUIData createFor(const std::string& name, float scale = 1.0f);
44 | 	};
45 | 
46 | 	// Reference to the global project observer
47 | 	ProjectObserver& observer;
48 | 
49 | 	// Reference to the global project assets
50 | 	ProjectAssets& assets;
51 | 
52 | 	// Current displayed scale of ui assets
53 | 	float assetScale;
54 | 
55 | 	// Target asset scale for smoothly interpolated asset scaling
56 | 	float targetAssetScale;
57 | 
58 | 	// Currently selected folders io node id
59 | 	static uint32_t selectedFolder;
60 | 
61 | 	// Currently selected io nodes id
62 | 	static uint32_t selectedNode;
63 | 
64 | 	// Checks for asset broser related inputs
65 | 	void evaluateInputs();
66 | 
67 | 	// Opens an io node using the system default application
68 | 	void openNodeInApplication(const NodeRef& node);
69 | 
70 | 	// Opens an io nodes path using the system default explorer
71 | 	void openNodeInExplorer(const NodeRef& node);
72 | 
73 | 	//
74 | 	// RENDERING FUNCTIONS
75 | 	//
76 | 
77 | 	// Renders navigation at given position and returns its size
78 | 	ImVec2 renderNavigation(ImDrawList& drawList, ImVec2 position);
79 | 
80 | 	// Renders side folder structure at given position and returns its size
81 | 	ImVec2 renderSideFolders(ImDrawList& drawList, ImVec2 position);
82 | 
83 | 	// Renders a side folder item for the folder structure
84 | 	void renderSideFolder(ImDrawList& drawList, FolderRef folder, uint32_t indentation);
85 | 
86 | 	// Renders all nodes for current selected folder at given position with given size
87 | 	void renderNodes(ImDrawList& drawList, ImVec2 position, ImVec2 size);
88 | 
89 | 	// Tries to render a node at the given screen position using its ui data created before
90 | 	bool renderNode(ImDrawList& drawList, NodeRef node, const NodeUIData& uiData, ImVec2 position);
91 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/audio_setup_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "editor_window.h"
 4 | 
 5 | class AudioSetupWindow : public EditorWindow
 6 | {
 7 | public:
 8 | 	void render() override;
 9 | };
10 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/console_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "editor_window.h"
 4 | 
 5 | #include <string>
 6 | #include <deque>
 7 | #include <vector>
 8 | 
 9 | #include <utils/console.h>
10 | 
11 | using LogType = Console::out::LogType;
12 | 
13 | struct ImVec2;
14 | 
15 | struct ConsoleLog {
16 | 	std::string origin;
17 | 	std::string content;
18 | 	LogType type;
19 | 
20 | 	ConsoleLog(const std::string& origin, const std::string& content, LogType type) :
21 | 		origin(origin),
22 | 		content(content),
23 | 		type(type)
24 | 	{};
25 | };
26 | 
27 | class ConsoleWindow : public EditorWindow
28 | {
29 | public:
30 | 	ConsoleWindow();
31 | 
32 | 	void render() override;
33 | 
34 | 	// Log to console
35 | 	static void log(const ConsoleLog& log);
36 | 
37 | 	// Get snapshot of current console logs
38 | 	static std::vector<ConsoleLog> snapshot();
39 | private:
40 | 	bool showMessages;
41 | 	bool showWarnings;
42 | 	bool showErrors;
43 | 
44 | 	static constexpr int32_t maxLogs = 300;
45 | 	static constexpr const char* messageIcon = ICON_FA_COMMENT;
46 | 	static constexpr const char* warningIcon = ICON_FA_TRIANGLE_EXCLAMATION;
47 | 	static constexpr const char* errorIcon = ICON_FA_CIRCLE_EXCLAMATION;
48 | 	static constexpr const char* clearIcon = ICON_FA_CROSS;
49 | 
50 | 	static std::deque<ConsoleLog> logs;
51 | 	static std::vector<ConsoleLog> logsToAdd;
52 | 
53 | 	// Draws a log
54 | 	void drawLog(ImDrawList& drawList, const ConsoleLog& log);
55 | 
56 | 	// Draws the latest log element and returns its size
57 | 	ImVec2 drawLatestLog(ImDrawList& drawList);
58 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/diagnostics_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <deque>
 4 | 
 5 | #include "editor_window.h"
 6 | 
 7 | class DiagnosticsWindow : public EditorWindow
 8 | {
 9 | public:
10 | 	DiagnosticsWindow();
11 | 
12 | 	void render() override;
13 | 
14 | private:
15 | 	std::deque<float> fpsCache;
16 | 	float fpsUpdateTimer;
17 | };
18 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/editor_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define IMGUI_DEFINE_MATH_OPERATORS
 4 | #include <imgui.h>
 5 | #include <glm/glm.hpp>
 6 | 
 7 | #include <time/time.h>
 8 | #include <utils/console.h>
 9 | 
10 | #include "../ui/editor_ui.h"
11 | #include "../runtime/runtime.h"
12 | #include "../ui/utils/ui_utils.h"
13 | #include "../ui/inspectables/inspectable.h"
14 | #include "../ui/components/im_components.h"
15 | #include "../ui/context_menu/context_menu.h"
16 | #include "../ui/collection/IconsFontAwesome6.h"
17 | #include "../ui/dynamic_drawing/dynamic_text.h"
18 | #include "../ui/dynamic_drawing/dynamic_content.h"
19 | 
20 | class EditorWindow
21 | {
22 | public:
23 | 	virtual void render() = 0;
24 | };
25 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/game_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "editor_window.h"
 4 | 
 5 | class GameWindow : public EditorWindow
 6 | {
 7 | public:
 8 | 	GameWindow();
 9 | 	void render() override;
10 | 
11 | private:
12 | 	void renderToolbar(ImDrawList& drawList, ImVec2 position);
13 | 	void renderGameView();
14 | 	void renderForegroundIndicators();
15 | 
16 | private:
17 | 	ImVec2 currentContentAvail; // Current windows size
18 | 	ImVec2 lastContentAvail; // Cache last windows size
19 | 
20 | 	ImVec2 lastWindowPosition; // Cache for last window position
21 | 	ImVec2 lastWindowSize; // Cache for last window size
22 | 
23 | 	bool windowFocused; // Set if game window is currently focused
24 | 	bool windowHovered; // Set if game window is currently hovered
25 | 
26 | 	ImVec4 gameViewBounds; // Bounds of game view (min x, min y, max x, max y)
27 | 
28 | 	DynamicContent noCameraIndicator; // Indicator for when theres no camera to render game view
29 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/insight_panel_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <memory>
 5 | #include <type_traits>
 6 | 
 7 | #include "editor_window.h"
 8 | 
 9 | class InsightPanelWindow : public EditorWindow
10 | {
11 | public:
12 | 	InsightPanelWindow();
13 | 
14 | 	void render() override;
15 | 
16 | 	template <typename T, typename... Args>
17 | 	static void inspect(Args&&... args)
18 | 	{
19 | 		// Make sure provided type is derived from inspectable
20 | 		static_assert(std::is_base_of_v<Inspectable, T>, "Only objects which are derived from class 'Inspectable' can be inspected!");
21 | 
22 | 		// Instantiate new inspectable
23 | 		inspected = std::make_unique<T>(std::forward<Args>(args)...);
24 | 	}
25 | 
26 | public:
27 | 	// Renders an image by the given backend texture id
28 | 	static void renderImage(uint32_t textureId, float aspectRatio, std::array<float, 2> margin = { 0.0f, 15.0f });
29 | 
30 | 	// tmp
31 | 	static inline uint32_t previewOutput;
32 | 
33 | private:
34 | 	// Currently inspected object
35 | 	static inline std::unique_ptr<Inspectable> inspected;
36 | 
37 | 	// Output texture of preview viewer
38 | 	size_t previewViewerOutput;
39 | 
40 | 	// Current height of preview viewer
41 | 	float previewViewerHeight;
42 | 
43 | 	// Transform of preview viewer camera
44 | 	TransformComponent previewCameraTransform;
45 | 
46 | private:
47 | 	// Renders the nothing inspected text
48 | 	void renderNoneInspected();
49 | 
50 | 	// Renders preview viewer by given preview renderer
51 | 	void renderPreviewViewer(ImDrawList& drawList, ImVec2 size);
52 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/post_processing_window.cpp:
--------------------------------------------------------------------------------
 1 | #include "post_processing_window.h"
 2 | 
 3 | #include "../ui/components/inspectable_components.h"
 4 | 
 5 | PostProcessingWindow::PostProcessingWindow(PostProcessing::Profile& targetProfile) : targetProfile(targetProfile)
 6 | {
 7 | }
 8 | 
 9 | void PostProcessingWindow::render()
10 | {
11 | 	std::string title = UIUtils::windowTitle("Post Processing");
12 | 	ImGui::Begin(title.c_str(), nullptr, EditorFlag::standard);
13 | 	{
14 | 		IMComponents::headline("Post Processing", ICON_FA_WAND_MAGIC_SPARKLES);
15 | 
16 | 		ImGui::Dummy(ImVec2(0.0f, 5.0f));
17 | 		IMComponents::label(ICON_FA_PENCIL "  Editing: Global Profile", EditorUI::getFonts().h4_bold);
18 | 		ImGui::Dummy(ImVec2(0.0f, 10.0f));
19 | 
20 | 		InspectableComponents::drawColor(targetProfile.color);
21 | 		InspectableComponents::drawMotionBlur(targetProfile.motionBlur);
22 | 		InspectableComponents::drawBloom(targetProfile.bloom);
23 | 		InspectableComponents::drawChromaticAberration(targetProfile.chromaticAberration);
24 | 		InspectableComponents::drawVignette(targetProfile.vignette);
25 | 		InspectableComponents::drawAmbientOcclusion(targetProfile.ambientOcclusion);
26 | 
27 | 		ImGui::Dummy(ImVec2(0.0f, 5.0f));
28 | 		ImGui::Separator();
29 | 		ImGui::Dummy(ImVec2(0.0f, 5.0f));
30 | 		if (IMComponents::buttonBig(ICON_FA_TRASH "  Reset All")) {
31 | 			PostProcessing::Profile defaultProfile;
32 | 			targetProfile = defaultProfile;
33 | 		}
34 | 	}
35 | 	ImGui::End();
36 | }
37 | 
38 | PostProcessing::Profile& PostProcessingWindow::getTargetProfile() {
39 | 	return targetProfile;
40 | }
41 | 
42 | void PostProcessingWindow::updateTargetProfile(PostProcessing::Profile& profile) {
43 | 	targetProfile = profile;
44 | }
45 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/post_processing_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "editor_window.h"
 4 | 
 5 | #include <rendering/postprocessing/post_processing.h>
 6 | 
 7 | class PostProcessingWindow : public EditorWindow
 8 | {
 9 | public:
10 | 	PostProcessingWindow(PostProcessing::Profile& targetProfile);
11 | 
12 | 	void render() override;
13 | 
14 | 	PostProcessing::Profile& getTargetProfile();
15 | 	void updateTargetProfile(PostProcessing::Profile& profile);
16 | 
17 | private:
18 | 	PostProcessing::Profile& targetProfile;
19 | };
20 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/registry_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <string>
 5 | #include <vector>
 6 | #include <unordered_map>
 7 | 
 8 | #include "editor_window.h"
 9 | 
10 | #include <ecs/ecs_collection.h>
11 | 
12 | struct HierarchyItem {
13 | 
14 | 	explicit HierarchyItem(EntityContainer entity, std::vector<HierarchyItem> children = {}) : entity(entity), children(children), expanded(false)
15 | 	{
16 | 	};
17 | 
18 | 	EntityContainer entity;
19 | 	std::vector<HierarchyItem> children;
20 | 	bool expanded;
21 | 
22 | 	bool operator==(const HierarchyItem& other) {
23 | 		return entity.id() == other.entity.id();
24 | 	}
25 | 
26 | };
27 | 
28 | class RegistryWindow : public EditorWindow
29 | {
30 | public:
31 | 	RegistryWindow();
32 | 
33 | 	void render() override;
34 | 
35 | private:
36 | 	// Renders the search bar
37 | 	void renderSearch(ImDrawList& drawList);
38 | 
39 | 	// Renders the current hierarchy as a whole
40 | 	void renderHierarchy(ImDrawList& drawList);
41 | 
42 | 	// Renders a given item and all of its children
43 | 	void renderItem(ImDrawList& drawList, HierarchyItem& item, uint32_t indentation);
44 | 
45 | 	// Renders the indicator for the item currently dragged
46 | 	void renderDraggedItem();
47 | 
48 | 	// Renders the context menu
49 | 	void renderContextMenu();
50 | 
51 | 	// Updates camera movement
52 | 	void updateCameraMovement();
53 | 
54 | 	// Builds the opened scene into a hierarchy
55 | 	void buildSceneHierarchy();
56 | 
57 | 	// Builds the children of a parent recursively
58 | 	void buildHierarchyChildren(HierarchyItem& parent);
59 | 
60 | 	// Sets a new target for the camera movement
61 | 	void setCameraTarget(TransformComponent* target);
62 | 
63 | 	// Performs vertical auto scroll if an item is dragged
64 | 	void performAutoScroll();
65 | 
66 | 	char searchBuffer[128];
67 | 
68 | 	// Set if the context menu was used within the last frame
69 | 	bool contextMenuUsed;
70 | 
71 | 	// Current hierarchy
72 | 	std::vector<HierarchyItem> currentHierarchy;
73 | 
74 | 	// Map of pointers to the currently selected items of the hierarchy sorted by their id
75 | 	std::unordered_map<uint32_t, HierarchyItem*> selectedItems;
76 | 
77 | 	HierarchyItem* lastSelected;
78 | 	HierarchyItem* lastHovered;
79 | 
80 | 	// Rect for dragged hierarchy items
81 | 	DynamicContent dragRect;
82 | 	bool draggingHierarchy;
83 | 
84 | 	bool cameraMoving;
85 | 	float cameraMovementTime;
86 | 	TransformComponent* cameraTarget;
87 | };


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/resource_viewer_window.cpp:
--------------------------------------------------------------------------------
 1 | #include "resource_viewer_window.h"
 2 | 
 3 | #include <glm/glm.hpp>
 4 | #include <implot.h>
 5 | 
 6 | #include <time/time.h>
 7 | #include <utils/fsutil.h>
 8 | #include <diagnostics/profiler.h>
 9 | #include <diagnostics/diagnostics.h>
10 | 
11 | ResourceViewerWindow::ResourceViewerWindow()
12 | {
13 | }
14 | 
15 | void ResourceViewerWindow::render()
16 | {
17 | 	std::string title = UIUtils::windowTitle("Resource Viewer");
18 | 	ImGui::Begin(title.c_str(), nullptr, EditorFlag::fixed);
19 | 	{
20 | 		ImDrawList& drawList = *ImGui::GetWindowDrawList();
21 | 
22 | 		IMComponents::headline("Resource Viewer", ICON_FA_DATABASE);
23 | 
24 | 		//
25 | 		// TEMPORARY!
26 | 		// Inefficient, just for debugging
27 | 		//
28 | 
29 | 		const auto& resources = ApplicationContext::resourceManager().readResources();
30 | 
31 | 		IMComponents::label("Resources allocated: ", EditorUI::getFonts().h4);
32 | 		ImGui::SameLine();
33 | 		IMComponents::label(std::to_string(resources.size()), EditorUI::getFonts().h4_bold);
34 | 
35 | 		ImGui::Dummy(ImVec2(0.0f, 5.0f));
36 | 		
37 | 		ImGui::BeginChild(EditorUI::generateId(), ImVec2(ImGui::GetContentRegionAvail()));
38 | 		{
39 | 			for (const auto& [id, resource] : resources) {
40 | 				IMComponents::label("ID " + std::to_string(id) + ": ", EditorUI::getFonts().p_bold);
41 | 				ImGui::SameLine();
42 | 
43 | 				IMComponents::label(resource->resourceName() + " - ");
44 | 				ImGui::SameLine();
45 | 
46 | 				ImVec2 pos = ImGui::GetCursorScreenPos();
47 | 				switch (resource->resourceState()) {
48 | 				case ResourceState::EMPTY:
49 | 					IMComponents::label("EMPTY", IM_COL32(255, 255, 0, 255));
50 | 					ImGui::SameLine();
51 | 					break;
52 | 				case ResourceState::QUEUED:
53 | 					IMComponents::label("QUEUED", IM_COL32(180, 180, 255, 255));
54 | 					ImGui::SameLine();
55 | 					break;
56 | 				case ResourceState::LOADING:
57 | 					IMComponents::label("CREATING...", IM_COL32(100, 255, 145, 255));
58 | 					ImGui::SetCursorScreenPos(pos);
59 | 					IMComponents::loadingBuffer(drawList, pos + ImVec2(74.0f, 3.0f), 5.0f, 2.0f, IM_COL32(255, 255, 255, 200));
60 | 					ImGui::SetCursorScreenPos(pos + ImVec2(83.0f, 0.0f));
61 | 					break;
62 | 				case ResourceState::READY:
63 | 					IMComponents::label("READY", IM_COL32(0, 255, 0, 255));
64 | 					ImGui::SameLine();
65 | 					break;
66 | 				case ResourceState::FAILED:
67 | 					IMComponents::label("FAILED", IM_COL32(255, 50, 50, 255));
68 | 					ImGui::SameLine();
69 | 					break;
70 | 				}
71 | 
72 | 				IMComponents::label("- Used by: ");
73 | 				ImGui::SameLine();
74 | 				IMComponents::label(std::to_string(resource.use_count() - 1));
75 | 			}
76 | 		}
77 | 		ImGui::EndChild();
78 | 	}
79 | 	ImGui::End();
80 | }


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/resource_viewer_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <deque>
 4 | 
 5 | #include "editor_window.h"
 6 | 
 7 | class ResourceViewerWindow : public EditorWindow
 8 | {
 9 | public:
10 | 	ResourceViewerWindow();
11 | 
12 | 	void render() override;
13 | };
14 | 


--------------------------------------------------------------------------------
/nuro-editor/ui/windows/viewport_window.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "editor_window.h"
 4 | 
 5 | #include "../ui/components/toggle_bar.h"
 6 | 
 7 | class ViewportWindow : public EditorWindow
 8 | {
 9 | public:
10 | 	ViewportWindow();
11 | 	void render() override;
12 | 
13 | private:
14 | 	void renderSceneView();
15 | 	void renderSceneToolbar(ImVec2 position, ImVec2 size);
16 | 	void renderTransformGizmos();
17 | 	void renderSpeedChangeIndicator();
18 | 
19 | 	void updateMovement(); // Update movement within scene view
20 | 
21 | private:
22 | 	glm::vec2 currentWindowSize; // Current windows size
23 | 	glm::vec2 lastWindowSize; // Cache last windows size
24 | 
25 | 	bool windowFocused; // Set if scene window is currently focused
26 | 	bool windowHovered; // Set if scene window is currently hovered
27 | 
28 | 	bool sceneViewRightclicked; // Set if scene viewport is currently rightclicked
29 | 	bool sceneViewMiddleclicked; // Set if scene viewport is currently rightclicked
30 | 
31 | 	glm::vec4 sceneViewBounds; // Bounds of scene view (min x, min y, max x, max y)
32 | 
33 | 	float movementSpeed; // Speed of camera movement within scene viewport
34 | 	float mouseSensitivity; // Scene viewport mouse sensitivity
35 | 	float scrollIncrementSpeed; // Speed for incrementing movement speed through mouse scrolling
36 | 	float speedChangeTimer; // Timer resetting when the speed is changed
37 | 	DynamicContent speedChangeIndicator; // Speed change indicator for speed change
38 | 
39 | 	ToggleBar mainToggles; // Main viewport settings
40 | 	ToggleBar playToggles; // Play settings
41 | 
42 | 	bool gamePaused; // Set if game is paused
43 | 	bool gameExecuting; // Set if game is executing (running or paused)
44 | 
45 | 	glm::vec2 moveAxis; // Current input axis for evaluating scene view movement
46 | 	float moveAxisSmoothingFactor; // Smoothing for key axis
47 | 	glm::vec2 mouseCurrent; // Current mouse position
48 | 	glm::vec2 mouseLast; // Last mouse position
49 | 	glm::vec2 mouseDelta; // Last mouse position
50 | 
51 | 	int32_t gizmoOperation; // Last used gizmo operation
52 | 	float gizmoScaleMin; // Limit for downscaling an object with a gizmo
53 | };


--------------------------------------------------------------------------------
/nuro-editor/utfcpp/README.md:
--------------------------------------------------------------------------------
 1 | ## UTF8-CPP Library
 2 | 
 3 | This folder contains the source files for **UTF8-CPP**, a third-party, header-only library for handling UTF-8 encoded text in C++.
 4 | 
 5 | ---
 6 | 
 7 | ### Source:
 8 | - Official repository: https://github.com/nemtrif/utfcpp
 9 | - License: Boost Software License 1.0 (BSL-1.0)
10 | 
11 | ### Notes:
12 | - The library is **header-only**, no separate compilation is required
13 | - Include `"utf8.h"` for usage
14 | - The original structure of the library has been preserved


--------------------------------------------------------------------------------
/nuro-editor/utfcpp/utf8.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2006 Nemanja Trifunovic
 2 | 
 3 | /*
 4 | Permission is hereby granted, free of charge, to any person or organization
 5 | obtaining a copy of the software and accompanying documentation covered by
 6 | this license (the "Software") to use, reproduce, display, distribute,
 7 | execute, and transmit the Software, and to prepare derivative works of the
 8 | Software, and to permit third-parties to whom the Software is furnished to
 9 | do so, all subject to the following:
10 | 
11 | The copyright notices in the Software and this entire statement, including
12 | the above license grant, this restriction and the following disclaimer,
13 | must be included in all copies of the Software, in whole or in part, and
14 | all derivative works of the Software, unless such copies or derivative
15 | works are solely in the form of machine-executable object code generated by
16 | a source language processor.
17 | 
18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
21 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
22 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
23 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 | DEALINGS IN THE SOFTWARE.
25 | */
26 | 
27 | 
28 | #ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
29 | #define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
30 | 
31 | /*
32 | To control the C++ language version used by the library, you can define UTF_CPP_CPLUSPLUS macro
33 | and set it to one of the values used by the __cplusplus predefined macro.
34 | 
35 | For instance,
36 |     #define UTF_CPP_CPLUSPLUS 199711L
37 | will cause the UTF-8 CPP library to use only types and language features available in the C++ 98 standard.
38 | Some library features will be disabled.
39 | 
40 | If you leave UTF_CPP_CPLUSPLUS undefined, it will be internally assigned to __cplusplus.
41 | */
42 | 
43 | #include "utf8/checked.h"
44 | #include "utf8/unchecked.h"
45 | 
46 | #endif // header guard
47 | 


--------------------------------------------------------------------------------
/nuro-editor/utfcpp/utf8/cpp11.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 Nemanja Trifunovic
 2 | 
 3 | /*
 4 | Permission is hereby granted, free of charge, to any person or organization
 5 | obtaining a copy of the software and accompanying documentation covered by
 6 | this license (the "Software") to use, reproduce, display, distribute,
 7 | execute, and transmit the Software, and to prepare derivative works of the
 8 | Software, and to permit third-parties to whom the Software is furnished to
 9 | do so, all subject to the following:
10 | 
11 | The copyright notices in the Software and this entire statement, including
12 | the above license grant, this restriction and the following disclaimer,
13 | must be included in all copies of the Software, in whole or in part, and
14 | all derivative works of the Software, unless such copies or derivative
15 | works are solely in the form of machine-executable object code generated by
16 | a source language processor.
17 | 
18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
21 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
22 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
23 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 | DEALINGS IN THE SOFTWARE.
25 | */
26 | 
27 | 
28 | #ifndef UTF8_FOR_CPP_a184c22c_d012_11e8_a8d5_f2801f1b9fd1
29 | #define UTF8_FOR_CPP_a184c22c_d012_11e8_a8d5_f2801f1b9fd1
30 | 
31 | #include "checked.h"
32 | 
33 | namespace utf8
34 | {
35 |     inline void append16(utfchar32_t cp, std::u16string& s)
36 |     {
37 |         append16(cp, std::back_inserter(s));
38 |     }
39 | 
40 |     inline std::string utf16to8(const std::u16string& s)
41 |     {
42 |         std::string result;
43 |         utf16to8(s.begin(), s.end(), std::back_inserter(result));
44 |         return result;
45 |     }
46 | 
47 |     inline std::u16string utf8to16(const std::string& s)
48 |     {
49 |         std::u16string result;
50 |         utf8to16(s.begin(), s.end(), std::back_inserter(result));
51 |         return result;
52 |     }
53 | 
54 |     inline std::string utf32to8(const std::u32string& s)
55 |     {
56 |         std::string result;
57 |         utf32to8(s.begin(), s.end(), std::back_inserter(result));
58 |         return result;
59 |     }
60 | 
61 |     inline std::u32string utf8to32(const std::string& s)
62 |     {
63 |         std::u32string result;
64 |         utf8to32(s.begin(), s.end(), std::back_inserter(result));
65 |         return result;
66 |     }
67 | } // namespace utf8
68 | 
69 | #endif // header guard
70 | 
71 | 


--------------------------------------------------------------------------------
/resources/editor-examples/empty-project/.project:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonkwl/nuro/60039f25f36d71950eeb53e230cc72495f037d9d/resources/editor-examples/empty-project/.project


--------------------------------------------------------------------------------
/resources/editor-examples/empty-project/assets/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonkwl/nuro/60039f25f36d71950eeb53e230cc72495f037d9d/resources/editor-examples/empty-project/assets/.gitkeep


--------------------------------------------------------------------------------
/resources/fonts/Icons/fa-solid-900-free.ttf:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:d2f0593540b0e33ba6de255a54f272d466e31144806956bea8cfdbf7edffc9bd
3 | size 426112
4 | 


--------------------------------------------------------------------------------
/resources/fonts/Inter/Inter_18pt-ExtraLight.ttf:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:8410d5b8b691adc1df06fc946c11efc85963a7e4ac6a35acbb1e392a997cc730
3 | size 343532
4 | 


--------------------------------------------------------------------------------
/resources/fonts/Inter/Inter_18pt-Light.ttf:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:f0e82b52327efcb68e1b181019ad81d6773bc5ee2addb0b3588d5712740054cd
3 | size 343704
4 | 


--------------------------------------------------------------------------------
/resources/fonts/Inter/Inter_18pt-Regular.ttf:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:3e5f90a0138b38de4cf4d779ad78391974ea1df776b9164842bdcbb60ce383c5
3 | size 342680
4 | 


--------------------------------------------------------------------------------
/resources/fonts/Inter/Inter_18pt-SemiBold.ttf:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:a8b276e25bb13dfa39cface35cc92aff9a7d5f1b96143f0df8c66351ccfed2a4
3 | size 343828
4 | 


--------------------------------------------------------------------------------
/resources/fonts/Inter/Inter_18pt-Thin.ttf:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:49af22a61adc89b3cba20525fd0a99d8bb39d111e6ccc73b1ab612810b754828
3 | size 343088
4 | 


--------------------------------------------------------------------------------
/resources/icons/assets/file.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:fc7f7f686bea75e21c2bc89ada5b9be1fd4436502c02a96b76dfb986852943c2
3 | size 11471
4 | 


--------------------------------------------------------------------------------
/resources/icons/assets/folder.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:212872b7a8bef7204e0fefb25ac2ab53c41cfc110bd16be7add6903ae417f115
3 | size 7710
4 | 


--------------------------------------------------------------------------------
/resources/icons/assets/font.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:e4365884cbcedb5e73f644e2aaab0b2b9c86a4178d46e190e28679d848fcfe49
3 | size 28194
4 | 


--------------------------------------------------------------------------------
/resources/icons/assets/material.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:db5fea7737bcfc35a7d6f8a53d218b048cdf8624b31cf8e5c7b519a5b2df9ce8
3 | size 160416
4 | 


--------------------------------------------------------------------------------
/resources/icons/assets/script.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:7642f4ecf74793c9647473311570f989e395fbb87121bc1c8201c689ae7afb2e
3 | size 16032
4 | 


--------------------------------------------------------------------------------
/resources/icons/assets/texture.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:70cfa5a90461b8a076faf0b381fe9c06d5fe085dd021a9f575a88e9234b09c74
3 | size 17814
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/audio_listener.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:1b29a0e10d4056670041041710ec7d3c5ac87c21b49b01dc618f35158e5d9057
3 | size 19064
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/audio_source.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:92f93a7f2d9b8896024b225b8f2649ef75089dc249121d86068489796c8abb64
3 | size 13536
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/box_collider.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:ca4d3bfbfb9208f429323a0024d724026d79e30e5289e419e01d443523b9dc3c
3 | size 13607
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/camera.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:e369440f6a8c1dd617ccaf86c3e9e0818470eb012e3aa4b5bf383eb8f05f0d5a
3 | size 14836
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/directional_light.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:ffc8aea9c77c57558d506e8e8ba363cfa0850499e5ac6b2eb9b6a3c1fedb6724
3 | size 19628
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/mesh_collider.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:5acd9c5b85462baa6caeb2dabfba4a45438fab5418de7abc025f15c515a6fe06
3 | size 21637
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/mesh_renderer.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:19c24e616b29a0d427625d75ffabd0e7b8fbdd0027bfc24601c8cc5433696140
3 | size 11159
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/point_light.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:4630cb793b6251256848c6c62e2749e55d54a185dd4d9e86c20f1bc335bbffad
3 | size 20032
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/rigidbody.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:b4f3d074cea0aebf65409890785731da326136a9299dd46a4a09a4dcd946a7fa
3 | size 27666
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/sphere_collider.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:b99f74bc5d36d79859645cd0dbc2781196965fa3c19331334eb3e54a1ddbdab4
3 | size 30943
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/spotlight.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:84b039eb64a6dc08367a10500089e03ad5e1b8e5ac340cf7f5bd8a926bc9f429
3 | size 20951
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/transform.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:43f6f2f8e270f3c01db121c01ec8c58e956741fe19efc92102eaf9fdcd9be22f
3 | size 23762
4 | 


--------------------------------------------------------------------------------
/resources/icons/components/velocity_blur.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:56b0ac73a354b3e9e746804c1e73e44b15546b6b06e9eceb191cfffc4355938f
3 | size 14338
4 | 


--------------------------------------------------------------------------------
/resources/icons/fallback/fallback_icon.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:4ae57b00b449d9941f3293e264f9f7d55bbac6d924b2da4e32fbc55050d88575
3 | size 51678
4 | 


--------------------------------------------------------------------------------
/resources/icons/fallback/fallback_texture.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:f426a61a06564aaa75f652ccec097611c5cbc0a98432c90cf1bca53da210b36f
3 | size 4355
4 | 


--------------------------------------------------------------------------------
/resources/icons/misc/listener_active.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:11cbbd7e1e9eb9cefe147e9046a408ee7f6577e7bbc1e775704829a4b5d0087b
3 | size 28933
4 | 


--------------------------------------------------------------------------------
/resources/icons/post-processing/ambient_occlusion.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:655f1ffdc46359a0f48e019f18421f13181ebe18ed5d7d4e54e34c5dee08c6b6
3 | size 14724
4 | 


--------------------------------------------------------------------------------
/resources/icons/post-processing/bloom.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:bc9653c9080dfccd1d9186d5699bc23aa701536cc9175acdedc88eac4ecb3516
3 | size 11056
4 | 


--------------------------------------------------------------------------------
/resources/icons/post-processing/chromatic_aberration.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:bc354c646b2e80db1d9cf7bad4771fdb43ff3d4570a67b939431cfc51073fd2e
3 | size 13373
4 | 


--------------------------------------------------------------------------------
/resources/icons/post-processing/color.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:a70577edcf3cfcdaed3f4750b9c7bcd9b997ee694f331ade29a41d5900ae20d6
3 | size 22187
4 | 


--------------------------------------------------------------------------------
/resources/icons/post-processing/motion_blur.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:8fd7b62ff37206c874d9b0033bcd153ab780f537cc8fa16634515ce8a196e81f
3 | size 21096
4 | 


--------------------------------------------------------------------------------
/resources/icons/post-processing/vignette.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:93aba2e2fcff5b1ac51d268a022333d4c14b786657bac08ddf911d4ddea6a38d
3 | size 15433
4 | 


--------------------------------------------------------------------------------
/resources/icons/scene/audio_source_gizmo.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:92f93a7f2d9b8896024b225b8f2649ef75089dc249121d86068489796c8abb64
3 | size 13536
4 | 


--------------------------------------------------------------------------------
/resources/icons/scene/camera_gizmo.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:35c8b18846145fc7e7c35e7540d0af86766eec097ffb084fe1fe90755c151d09
3 | size 54619
4 | 


--------------------------------------------------------------------------------
/resources/icons/scene/directional_light_gizmo.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:ffc8aea9c77c57558d506e8e8ba363cfa0850499e5ac6b2eb9b6a3c1fedb6724
3 | size 19628
4 | 


--------------------------------------------------------------------------------
/resources/icons/scene/point_light_gizmo.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:566da7092864a0c5f39e3635a9b80df33f4f5701462e5637e4124802bc1f7880
3 | size 46827
4 | 


--------------------------------------------------------------------------------
/resources/icons/scene/spotlight_gizmo.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:84b039eb64a6dc08367a10500089e03ad5e1b8e5ac340cf7f5bd8a926bc9f429
3 | size 20951
4 | 


--------------------------------------------------------------------------------
/resources/icons/shared/failed.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:35db74d7560ee9a888d6653c429e279c82e618b56d5dcc6cda7fe7e9bb5735b1
3 | size 11538
4 | 


--------------------------------------------------------------------------------
/resources/icons/shared/logo.png:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:30489354d0cac8f5ebb4c498813f8e62d082b2f3c1dcba65b187528485f8a133
3 | size 23720
4 | 


--------------------------------------------------------------------------------
/resources/primitives/cube.fbx:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:5836e9ccad757e040be76706bcffc5cdee1d4dcc4b368edddd10fe53cdf7f585
3 | size 15052
4 | 


--------------------------------------------------------------------------------
/resources/primitives/plane.fbx:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:68706f8a3f0321b4ab4a88d9616d5c4806aa047d2846a3e7555b0f2cfa809afc
3 | size 11612
4 | 


--------------------------------------------------------------------------------
/resources/primitives/sphere.fbx:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:f612b9c7cf7a2437e7e6a9d2d940fecf207adecd152419be11350f99fde24ea9
3 | size 81548
4 | 


--------------------------------------------------------------------------------
/resources/primitives/sphere_lowpoly.fbx:
--------------------------------------------------------------------------------
1 | version https://git-lfs.github.com/spec/v1
2 | oid sha256:8d17c9e9f5ae0465910efe45354090f6f48c56697f6e6b4a23d308f1a74c45b1
3 | size 16428
4 | 


--------------------------------------------------------------------------------
/vcpkg-configuration.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "default-registry": {
 3 |     "kind": "git",
 4 |     "baseline": "f0376cb987beefabcbef170a0764dc363f789b78",
 5 |     "repository": "https://github.com/microsoft/vcpkg"
 6 |   },
 7 |   "registries": [
 8 |     {
 9 |       "kind": "artifact",
10 |       "location": "https://github.com/microsoft/vcpkg-ce-catalog/archive/refs/heads/main.zip",
11 |       "name": "microsoft"
12 |     }
13 |   ]
14 | }
15 | 


--------------------------------------------------------------------------------
/vcpkg.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"dependencies": [
 3 | 		"assimp",
 4 | 		"entt",
 5 | 		"glad",
 6 | 		"glfw3",
 7 | 		"glm",
 8 | 		"physx",
 9 | 		"stb",
10 | 		"nlohmann-json",
11 | 		"ffmpeg",
12 | 		"openal-soft",
13 | 		"efsw",
14 | 		"reflectcpp"
15 | 	]
16 | }


--------------------------------------------------------------------------------