Do some research and see which is better.

There should be grid lines in the editor, for reference.

Prebake shadows into textures for static objects and lights.

Add circles to debug drawing facilities.

Expose ParticleEmitter to scripts.

Entities should be selected by clicking on the with the mouse.

Ability to compile without profiling in order to increase performance.

Fix crash when killing a script component that has a registered event.

Implement cube maps for reflections

Implement custom memory allocation.

Store model matrices and bucketize updates.

Implement heightmap terrain, and perhaps tools to edit this.

For profiling tools.

Reflections in screen space.

AppVeyor build is currently failing due to problem with OpenAL Soft and CMake 11.0. Maybe updating OpenAL Soft will help.

Add sphere to debug facilities.

Instead of using pointers we should find a solution that allows for contiguous storage of entities and components.

Entities should be able to be translated/scaled/rotated using a set of widgets: Arrows for translation, knobs for scale, circles for rotation.

Implement SSAO.

Expose mesh component to scripts.

Used for displaying 2D textures in a more intuitive manner than "faking" it with a 3D rect. Useful for eg. GUI (or 2D games).

Replace current physics engine with Bullet physics (or better).

Create a vulkan renderer.

Cache scripting stuff in order to increase performance.

Renaming resources will not move the resource file, meaning it won't be found when used. Additionally, there is no check to see if there are name collisions.

Implement shadow mapping. Preferably real time solution.
Minimum requirement is 10fps in an empty scene with a plant casting shadows on a plane.

Expose material component to scripts.

Replace current phong shading with PBR.

Expose animation component to scripts.

Having Android support would be really neat. However, there are currently many parts of the engine that are desktop specific.

• We need to target OpenGL ES. Preferably version 2.0 as that's the most widely available. Right now we're using both SSBOs and compute shaders which are 3.1. We could do target-specific things but having a single GL implementation is very desirable. That means either targeting OpenGL ES 3.1 or doing what Godot does and targeting OpenGL ES 2.0 / OpenGL 3.3.
• We're currently using GLFW for window/context creation and input. GLFW only supports desktop. In general, I'd like to decouple window creation and input more. This may be difficult.
• Investigate how to build C++ apps for Android and find a way to do this cleanly.

Ability to remove components by way of script.

GLEW loads just about everything, even tons of extensions we don't use. glad seems like a better alternative as it allows us to load only the functionality we need.

Show editable path to the current directory.
Differentiate between directories and files.

Right now, the doxygen files are kept in the top-level directory. These should be moved down to the subdirectories of each library. Additionally, use copydoc to avoid having duplicate doxygen comments for virtual methods.

Go from using our own implementation to using std::filesystem. It should simplify things a bit and make code more portable.

Settings that can be set on a per game basis and editable in the editor.

The current particle system is really bad. Delta time is hardcoded, it's unintuitive to use, doesn't allow sorting and in general is not powerful or useful. The best solution is probably to rewrite it from scratch.

glm::transpose and glm::inverse

Identify parts of the engine that can be parallelificated and parallelify them.

Enable the creation of skyboxes.
Perhaps as a part of the camera.

Stream assets, i.e level of detail, load meshes and textures when needed.

Implement networking backend and component.