adriengivry / overload Goto Github PK
View Code? Open in Web Editor NEW3D game engine with lua scripting
Home Page: https://overloadengine.org/
License: MIT License
3D game engine with lua scripting
Home Page: https://overloadengine.org/
License: MIT License
We should be able to open the engine documentation through the game editor (Like our portfolio links and the scripting API link).
Documentation link : http://overloadengine.org/documentation
There is no need to pass this parameter to the camera constructor because the camera doesn't even use it.
It would be nice to be able to find a reference to an asset into the current scene. We could add a "Find all references" option on the asset browser file contextual menu and show these references into the hierarchy
During the production I found useful to implement some test widgets directly in OvEditor to avoid recompiling OvUI.
A TestWidget class is remaining in the HelpWindow of OvEditor, we should just remove this class. We should also verify that there is no reference to it somewhere in the engine.
We should be able to add profiler spies into our Lua code in order to profile it
Implementing an editor tool that can generate a glsl file using a node based approach.
We should be able to create:
We should be able to create the graph using OvUI
Our maths library is currently implemented the old scalar way. It could be great to vectorize our maths library using SIMD intrinsics.
CPU usage isn't critic for now, this feature makes more sense in combination with morphing and skinning algorithms that we could implement in the future.
As we target OpenGL 4.3, which is relatively recent (August 6th 2012), we can use SSE4.1 (2006) and AVX (2011) instruction sets.
In this implementation, we should avoid extending our data structures that are non-multiples of 16 bytes (Ex: Vector2
, Vector3
, ...). The usage of SIMD shouldn't affect the actual memory usage.
In OvDebug we currently have 2 namespaces :
OvDebug::API
OvDebug::Utils
We shouldn't have this OvDebug::Utils
and we should instead have all of this namespace content directly in OvDebug
.
In the asset browser, when we open a folder containing some texture, we are freezing the editor while these textures are loaded for preview. We could instead load these textures asynchronously to prevent the editor from freezing and to have a smoother asset browsing.
In order to be more productive while creating a scene with Overload, we should be able to create templates (prefabs). These are basically an xml serialized version of an actor that we can drag and drop into scenes.
We can start with a very basic system without the possibility to edit tempaltes/prefabs, but later it would be nice to have an editor for these kind of resources.
When we deserialize elements we can't provide a default value if the parameters hasn't been found in the XML. We should be able to provide this default value in all case or to give information to the caller about the deserialiation result
Sometimes when duplicating and deleting some actors that has children the engine crashes.
It still being unclear how to reproduce this bug but you can try this :
It could be nice to have the possibility to delete a selected actor using [Del] key (In both SceneView and Hierarchy)
Problem this feature should fix
We should be able to setup a camera into orthographic (For 2D) or perspective mode (For 3D).
Expected solution
CreateOrthographic
method into OvMaths
OvRendering::LowRenderer::Camera
OvCore::ECS::Components::CCamera
OvCore::ECS::Components::CCamera
Lights using negative intensity are not considered in the light effect radius calculation. We should use the absolute of the light intensity
There is no point having a method there. Morehover, it is inconsistent with OvMaths::FVector3
which has some constants (Zero
, One
...).
A nice optimization would be to have frustum culling. This can be achieved simply by saving a sphere (Bounding sphere) in our models and use this sphere in conjonction with actor transform (Scale and position) to determine if the model is in the camera frustum. Frustum culling should be an option per model renderer. Sometimes (With particle system for instance) we wan't to disable this effect because shaders can actually render an object outside of its base geometry.
Example
Implementation example
https://github.com/gametutorials/tutorials/blob/master/OpenGL/Frustum%20Culling/Frustum.cpp
When we open a project, we are currently not checking that the "Assets" and "Scripts" folders exists. If they don't, it will result in a crash.
We should add security and error message if one of these folders doesn't exist.
Hi,
The diff can be show here
Strangely, this bug causes crash only when using my cmake scripts...
The original sln
project does not...
P.S.
Uhm... I wrote a simple cmake script, and is about to make a PR...
But I just found... I've done the same thing... there is already a PR doing the same thing. ;-(
My version of cmake scripts are simpler (more straight forward)... So I decided to give my PR.
So I just tell you the bug I found..
Regards.
BTW. I think you guys would better use a .clang-format
file to format the code
We should add an auto-save option (That can be disabled) for the current scene.
Problem this feature should fix
The hierarchy has a lack of information about GameObjects states (Enabled/Disabled)
Expected solution
We can add some icons to the left of GameObjects tree nodes in the hierarchy that can show if the GameObject is enabled or disabled. Layer, with a future prefab system, we will be able to use this icon system to identify GameObjects that are instances of a prefab.
Currently the physics seems being dependent of the framerate. If you try to jump in a game scene, the jump force will depend on the framerate while it shouldn’t. To reproduce this issue, you can disable vertical synchronization and jump
Problem this feature should fix
When using Overload for the first time, it is sometimes unclear what you can do with the engine. Morehover, some users want to be instantly able to try the engine (Play with assets, modify scripts/shaders).
Expected solution
We should add a sample project that our users can use to discover the capabilities of the engine. This can be pretty similar to our "Showroom" sample, but with a focus onto user experience (Clean project, size is important)
Currently we use framebuffers directly in OvEditor
. We should wrap the framebuffer object into a class in OvRendering
and use it in the editor.
Technically, we should have no OpenGL call in the editor, the use of the OpenGL backend should be transparent to the editor.
We should expose new frustum culling settings to lua:
Camera
frustum culling for geometryCamera
frustum culling for lightsModelRenderer
frustum behaviourWe should be able to pick an actor (With a component such as CPhysicalObject
or CMeshRenderer
) by simply clicking on it.
They are 2 approaches to solve this issue:
Creating an editor physical world (Requires to split PhysicsEngine
into 2 classes, such as PhysicsEngine
and World
, as we did with @BenjaminViranin in the first physics implementation) and picking actors with raycasts. We will have to implement a layer system for the physics (Default, Editor, EditorOverlay). We will need to implement a PhysicalMesh system to ensure a good selection UX.
Creating a rendering pass (In a framebuffer) of the scene with unlit colors. Each color can represents a different actor. We can attribute colors depending on actors IDs (Ex: if an actor is rendered with a unlit color of rgb(1, 0, 0) it means that its ID in the scene is 1). This rendering pass is done when a mouse click occurs, and we will have to check the mouse position in the rendered texture, find the color under the selected pixel, and convert it to an actor ID. This solution implies that we wrap the framebuffer into an RAII-style class, like @maxbrundev did for other buffers. As we need to render the scene using unlit shader, and that Overload doesn't supports vertex and fragment shader in separated files, we can't make particle selection works with this approach. We can fix this drawback by supporting vertex and fragment shader in different files, so our rendering pass will keep vertex shaders but replace fragment shaders by unlit ones.
Currently, the editor OpenGL version set in OvEditor is incorrect. We are setting the major version 2 times instead of setting the major and the minor version.
See : OvEditor --> Context.cpp
The version that we should be using is 4.3 (Minimum GL version that supports SSBO).
This issue is kind of critical and we should create a new release of Overload for that (1.0.1).
We should support adding custom post-processing into our scenes.
This will require to improve OvRendering
to provide a proper abstraction layer for Framebuffer
and RenderTexture
Overload isn't using any pch
system for now.
We should start using pch
in our different projects to reduce compilation time.
Problem this feature should fix
A new user of Overload, after downloading the latest release, can feel lost.
Expected solution
It could be nice to have some documentation to give our users the best first time experience possible.
Exemple of a guide for Unity beginners (Unofficial) : https://www.raywenderlich.com/unity/paths/learn
Sometimes that camera jumps when moving into the scene view.
The behaviour isn't precisely defined, you can try to reproduce it by moving in the scene view or to spam the right click in this view.
We should be able to open an Overload project (.ovproject) by right clicking on the project file and selecting "Open with... Overload".
In order to make this work, we should support starting the editor with command line arguments (The project path will be given as an argument).
The OvEditor main should read this path and open the project instead of opening the project hub.
When we pick an actor in a scene, we expect the hierarchy to focus it in order to manipulate it. We should add this behaviour. Scene hierarchy should expend to show the focused actor.
Tip: We can recursively iterate through select actor parent and expend their matching node in the heriarchy
Description
As some major features has been introduced after 1.2, we are almost ready to deploy an 1.3 build. However, we have to enter a QA pass phase to ensure these new features aren't bringing new bugs to Overload
Expected
Tracking bug introduced by each new features from 1.3.
do you have a plan to support other platform? such as linux, mac? that would be so cool!
We should consider actor bounding spheres to focus them efficiently
When you open a project directly (Open with... Overload) without using the project hub, this project won't be added to projects.ini. We should consider these projects
In the editor we encounter this case multiple times:
Text
)Text
inherits from data widget, we can add a DataDispatcher
plugin to itDataDispatcher
or attach a referenceAnother approach is to use events (OnValueChanged += ...
) to keep, for example, our components up-to-date on the UI (And vice-versa).
It is very tedious to do that, I thought about a way to instanciate an object that can be a reference to another instance or directly a value (Like with our AudioListener
which holds a transform pointer or instanciate its own one, with a m_internalTransform
boolean to keep track of the memory management mode).
I added the ReferenceOrValue
class that allow a such behaviour:
int toto = 5;
ReferenceOrValue<int> foo{ 1 };
ReferenceOrValue<int> bar{ std::ref(toto) };
bar= 8; // Toto is modified, because bar holds a reference to toto
foo = 3; // Foo value is modified, because it holds no reference
This way, we can create a UI widget (Ex: Text
) with its content as a ReferenceOrValue<std::string>
instead of std::string
which can be a reference to a component value or a simple std::string
. (No more need to add a plugin or use events to keep the UI up-to-date on the component value because the UI will directly affect this value).
Currently we have a "Help" window that can be enabled via the "Window" menu in the menu bar. We should move this element to the help menu as it makes more sense to find it there.
We should be able to undo and redo editor actions to make Overload less destructive. We can for example store editor commands in classes with a "Do" and "Undo" method to be able to undo any command. These commands can be saved into a stack after they are executed.
We should split light SSBOs into multiple SSBOs to prevent useless shader branching
Note: This change will break any custom shader made with Overload.
Having a search bar in the hierarchy could really help to navigate into our scene entities. This could allow searching by name or component type
We should be able to handle gamepads in OvWindowing.
After that, we would need to add some binding for Lua in order to use gamepads in our gameplay logic
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.