Prepare model rendering.

Author: Flone-dnb

README.md

@@ -6,10 +6,9 @@ Supported platforms: Windows (x64), Linux (x64 and ARM64).
 
 # Roadmap
 
-- [X] Simple ECS
-- [ ] Config management (progress, settings, etc.)
-- [ ] Type reflection
 - [ ] Forward renderer using OpenGL ES 2.0
+- [ ] Config management (settings, input, progress)
+- [ ] Type reflection
 - [ ] GLTF/GLB import
 - [ ] GUI
 - [ ] Audio

docs/Manual.md

@@ -1 +1,51 @@
+# Manual
+
+This is a manual - a step-by-step guide to introduce you to various aspects of the engine. This manual will not explain every piece of code, only some high-level entities and their usage, more specific documentation can be always found in the struct/function/variable documentation in the source code, every code entity is documented so you should not get lost.
+
+# Project manager
+
 TODO
+
+# Thread safety
+
+The engine is single threaded and expects all functions to be executed in a single (main) thread. Only game resource loading (deserialization) is asynchronous (so you can show a loading screen while loading game resources).
+
+# Memory leak checks
+
+In debug builds the engine has memory leak checks enabled (thanks to CRT library on Windows and ASAN on Linux). Look for the output/debugger output tab of your IDE after running your project. If any leaks occurred it should print about them. You can test whether the memory leak checks are enabled or not by doing something like this:
+```C
+malloc(1);
+// not using `free`
+```
+run your program that has this code and after your program is finished you should see a message about the memory leak in the output/debugger output tab of your IDE.
+
+# Naming
+
+Engine types have the `te_` prefix (tiny engine). Functions have filename prefix so for example if you include `renderer.h` all of its functions will start with the `renderer_` prefix.
+
+# Core objects
+
+When the game is running the object ownership structure looks like this:
+
+- `te_window` (i.e. game window) owns:
+    - `te_game_manager` which manages core engine systems like:
+        - `te_renderer`
+        - `te_world` owns game entities, you can think of this as a game level
+            - your game objects are here
+        - etc.
+
+This means that for example when you query `te_window` pointer in some of your game objects you should not free/destroy received pointer, that pointer will be valid during the whole lifetime of your game object.
+
+# Managing pointers
+
+When working with the engine you would often see the following approach: in order to create some engine object use `..._create()` function and later `..._destroy()` to destroy it. For example in order to create a camera (game object):
+
+```C
+#include "game/camera.h"
+
+te_camera* camera = camera_create();
+// later ...
+camera_destroy(camera);
+```
+
+When the engine returns a pointer to you (like in the example above) often you need to make sure to free/destroy the pointer but in some cases you should not do that for example when the engine returns pointer to the game's window, in these cases the documentation for the function will specifically state that you should not free/destroy returned pointer so make sure to read the docs on the functions you are using.

res/engine/shader/model.frag.glsl

@@ -0,0 +1,12 @@
+varying vec3 frag_pos;
+varying vec3 frag_normal;
+varying vec2 frag_uv;
+
+uniform vec4 color;
+
+void main(void) {
+    // Normals may be unnormalized after the rasterization (when they are interpolated).
+    vec3 frag_normal_unit = normalize(frag_normal);
+ 
+    gl_FragColor = color;
+} 

res/engine/shader/model.vert.glsl

@@ -0,0 +1,20 @@
+attribute vec3 pos;
+attribute vec3 normal;
+attribute vec2 uv;
+
+varying vec3 frag_pos;
+varying vec3 frag_normal;
+varying vec2 frag_uv;
+
+uniform mat4 view_proj_mat;
+uniform mat4 world_mat;
+uniform mat3 normal_mat;
+
+void main(void) {
+    vec4 world_pos = world_mat * vec4(pos, 1.0F);
+    gl_Position = view_proj_mat * world_pos;
+
+    frag_pos = world_pos.xyz;
+    frag_normal = normal_mat * normal;
+    frag_uv = uv;
+} 

src/engine_lib/CMakeLists.txt

@@ -13,25 +13,26 @@ set(PROJECT_SOURCES
     src/misc/globals.c
     src/misc/error.c
     src/game_manager.c
-    src/renderer.c
     src/world.c
-    src/ecs/ecs.c
-    src/ecs/transform_component.c
-    src/ecs/camera_component.c
-    src/ecs/camera_system.c
+    src/render/renderer.c
+    src/render/model_renderer.h
+    src/render/model_renderer.c
+    src/render/shader_manager.c
+    src/game/camera.c
+    src/game/model.c
+    include/math_funcs.h
     include/window.h
     include/io/log.h
     include/io/paths.h
     include/io/filesystem.h
     include/misc/globals.h
     include/misc/error.h
     include/game_manager.h
-    include/renderer.h
+    include/render/renderer.h
+    include/render/shader_manager.h
     include/world.h
-    include/ecs/ecs.h
-    include/ecs/transform_component.h
-    include/ecs/camera_component.h
-    include/ecs/camera_system.h
+    include/game/camera.h
+    include/game/model.h
 )
 
 # Define targets (one without any specific macros and another for compilation with editor).
@@ -47,6 +48,9 @@ add_library(${ENGINE_LIB_TARGET_FOR_EDITOR} STATIC ${PROJECT_SOURCES})
 tiny_engine_configure_target(${ENGINE_LIB_TARGET})
 tiny_engine_configure_target(${ENGINE_LIB_TARGET_FOR_EDITOR})
 
+target_include_directories(${ENGINE_LIB_TARGET} PRIVATE src)
+target_include_directories(${ENGINE_LIB_TARGET_FOR_EDITOR} PRIVATE src)
+
 # Define editor macros for editor's version of the engine_lib.
 target_compile_definitions(${ENGINE_LIB_TARGET_FOR_EDITOR} PUBLIC ENGINE_EDITOR)