tests: added signal test, rebuilt documentation

Author: San7o

Makefile

@@ -36,7 +36,7 @@ HTML_INTRO      := utils/website/intro.html
 HTML_OUTRO      := utils/website/outro.html
 TMP_FILE        := /tmp/padoc-out.html
 HIGHLIGHT_STYLE := tango
-PANDOC_FLAGS    := --highlight-style ${HIGHLIGHT_STYLE}
+PANDOC_FLAGS    := --highlight-style ${HIGHLIGHT_STYLE} --ascii
 
 html: doxygen ${HTML} ## Generate website and documentation
 
@@ -48,12 +48,13 @@ doxygen: ## Generate html documentation
 	cp -r docs/*.jpg ${HTML_DIR}
 
 $(HTML_DIR)/%.html: ${DOCS_DIR}/%.md ${HTML_INTRO} ${HTML_OUTRO} | ${HTML_DIR}
-	pandoc $< -o ${TMP_FILE} ${PANDOC_FLAGS}
+	pandoc $< -f markdown-smart -t html -o ${TMP_FILE} ${PANDOC_FLAGS}
 	cp ${HTML_INTRO} $@
 	cat ${TMP_FILE} >> $@
 	cat ${HTML_OUTRO} >> $@
 	sed -i 's/\.md/\.html/g' $@
 	sed -i 's/.\/html/.\//g' $@
+	sed -i "s/’/\'/g" $@
 
 $(HTML_DIR):
 	mkdir -p ${HTML_DIR}

docs/BUILD.md

@@ -43,6 +43,9 @@ cmake -Bbuild
 cmake --build build -j$(nproc)
 ```
 
+For debug builds, specify `-D CMAKE_BUILD_TYPE=Debug`. This will
+generate all debug information and enable address sanitization.
+
 For the static library:
 
 ```bash

docs/GUIDE.md

@@ -317,36 +317,17 @@ TODO
 
 ## Audio
 
-The audio subsystem is very simple: there are audio streams and audio
-files, you can play an audio file on a stream and stop it. Each stream
-can play only one audio at a time, so you need to have multiple
-streams if you want to play multiple sounds at the same time.
-
-You can load an audio file like so:
-
-```cpp
-Audio::load("guitar", "assets/audio/guitar.wav");
-```
-
-We are identifying this audio file with the name `guitar`.
-
-You can create a stream with the name "music" like so:
+TODO
 
 ```cpp
-Audio::create_stream("music");
-```
-
-And finally play the `guitar` audio like so:
+auto guitar_sound_asset = SoundAsset::Builder()
+  .path("examples/assets/audio/guitar.wav")
+  .build();
+auto guitar_sound = Sound(guitar_sound_asset.value());
 
-```cpp
-Audio::play("guitar");
+guitar_sound.play();
 ```
 
-You can Pause and Resume streams with `brenta::audio::stream_pause` and
-`brenta::audio::stream_resume`, set the volume and stop it. You can find
-the API in `Brenta::Audio`.
-
-
 ## Opengl
 
 TODO
@@ -367,34 +348,45 @@ GPU so the engine can handle lots and lots of particles. Here's a
 quick look on the API:
 
 ```cpp
-auto emitter = ParticleEmitter::Builder()
-       .starting_position(glm::vec3(0.0f, 0.0f, 5.0f))
-       .starting_velocity(glm::vec3(0.0f, 5.0f, 0.0f))
-       .starting_spread(glm::vec3(10.0f, 10.0f, 10.0f))
-       .starting_time_to_live(0.5f)
-       .num_particles(1000)
-       .spawn_rate(0.01f)
-       .scale(1.0f)
-       .atlas_path"assets/textures/particle_atlas.png")
-       .atlas_width(8)
-       .atlas_height(8)
-       .atlas_index(45)
-       .build();
-
-// Inside the game loop:
-emitter.update(Window::get_time().get_delta());
+auto emitter =
+  ParticleEmitter::Builder()
+    .with_camera(camera)
+    .starting_position(glm::vec3(0.0f, 0.0f, 0.0f))
+    .starting_velocity(glm::vec3(0.0f, 5.0f, 0.0f))
+    .starting_spread(glm::vec3(3.0f, 10.0f, 3.0f))
+    .starting_time_to_live(0.5f)
+    .num_particles(1000)
+    .spawn_rate(0.99f)
+    .scale(1.0f)
+    .atlas_path("examples/assets/textures/particle_atlas.png")
+    .atlas_width(8)
+    .atlas_height(8)
+    .atlas_index(3)
+    .build();
+
+// Inside the main loop
+emitter.update(delta_time);
 emitter.render();
 ```
 
 ### Text
 
 TODO
 
-The `brenta::text` subsystem allows you to render text on the screen. You can
-set the font and font size of your text, and render it in the main loop like
-this:
 ```cpp
-Text::render_text("Hello OpenGL!", x, y, scale, glm::vec3(r, g, b));
+auto font     = Font("examples/assets/fonts/arial.ttf", 100);
+auto font_ptr =
+  tenno::make_shared<Font>(tenno::move(font));
+
+Text hello = {
+  "Hello OpenGL!",
+  25.0f,
+  25.0f,
+  1.0f,
+  Color::yellow(),
+  font_ptr
+};
+hello.render();
 ```
 
 ## Renderer
@@ -491,12 +483,11 @@ e.add_component<PhysicsComponent>(10.0f);
 
 ### System
 
-A System is a function that gets called at each Tick. It contains all
-the logic of the World. You will interact with the Entities,
-Components and Resources via queries. You can specify an entity to
-query by adding components to `system<...>`, the World will provide
-you with an `std::vector<entity_t>` of the entities that have all the
-components you specified.
+A System is a function that gets called at each Tick and implements
+the update logic of the World. You can specify entities to query by
+adding components to `system<...>`, the World will provide you with an
+`std::vector<entity_t>` of the entities that have all the components
+you specified.
 
 Here is an example:
 
@@ -546,7 +537,7 @@ Here is an high level simplified view of those objects:
 ![image](https://github.com/user-attachments/assets/d76b238d-56f1-4b57-8140-400af6ed1d23)
 
 
-## Scene graph
+## Node graph
 
 TODO
 
@@ -558,6 +549,10 @@ TODO
 
 TODO
 
+## Node Components
+
+TODO
+
 ### Scripts
 
 TODO

docs/html/BUILD.html

@@ -9,15 +9,14 @@
     <div class="topnav">
       <a href="./index.html">Brenta Engine</a>
       <a href="./DESIGN.html">Design</a>      
-      <a href="./BUILD.html">Build</a>
       <a href="./GUIDE.html">Guide</a>
-      <a href="./CONTRIBUTING.html">Contributing</a>
+      <a href="./BUILD.html">Build</a>
       <a href="./annotated.html">Data structures</a>
       <a href="./files.html">Files</a>
       <a href="https://github.com/San7o/Brenta-Engine">Github</a>
     </div>
 <h1 id="building-the-engine">Building the engine</h1>
-<p>Brenta-Engine is written C++23 and uses <code>cmake</code> as it’s
+<p>Brenta-Engine is written C++23 and uses <code>cmake</code> as it's
 build system. You can compile the engine as a static or shared library
 for both Windows and Linux.</p>
 <h2 id="dependencies">Dependencies</h2>
@@ -45,6 +44,9 @@ <h2 id="build">Build</h2>
 <div class="sourceCode" id="cb3"><pre
 class="sourceCode bash"><code class="sourceCode bash"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="fu">cmake</span> <span class="at">-Bbuild</span></span>
 <span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="fu">cmake</span> <span class="at">--build</span> build <span class="at">-j</span><span class="va">$(</span><span class="fu">nproc</span><span class="va">)</span></span></code></pre></div>
+<p>For debug builds, specify <code>-D CMAKE_BUILD_TYPE=Debug</code>.
+This will generate all debug information and enable address
+sanitization.</p>
 <p>For the static library:</p>
 <div class="sourceCode" id="cb4"><pre
 class="sourceCode bash"><code class="sourceCode bash"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="fu">cmake</span> <span class="at">-Bbuild</span> <span class="at">-DBUILD_SHARED_LIBS</span><span class="op">=</span>off</span>

docs/html/CONTRIBUTING.html

@@ -9,27 +9,13 @@
     <div class="topnav">
       <a href="./index.html">Brenta Engine</a>
       <a href="./DESIGN.html">Design</a>      
-      <a href="./BUILD.html">Build</a>
       <a href="./GUIDE.html">Guide</a>
-      <a href="./CONTRIBUTING.html">Contributing</a>
+      <a href="./BUILD.html">Build</a>
       <a href="./annotated.html">Data structures</a>
       <a href="./files.html">Files</a>
       <a href="https://github.com/San7o/Brenta-Engine">Github</a>
     </div>
 <h1 id="design">Design</h1>
-<p>I could tell you that the Brenta engine was perfectly designed, with
-a clear vision from its inception, with a beautiful and powerful API
-that makes programming truly enjoyable. Except the fact that it would be
-a lie. It does not mean that I don’t find the current design and API
-beautiful and fun - I think Brenta is a powerful engine - but its
-development has been more iterative than meticulously designed. I
-rewrote huge parts of the engine many many times, to the point where I
-am not scared to do big refactoring anymore - that is just routine - and
-I know I am deemed to repeat this process again. But through these many
-refactoring, the API reached a point where all objects work well
-together and you can reason about them through what I call the
-“architecture” or “design” of the engine. This is what I aim to describe
-in this documents.</p>
 <p>Game engines are complex pieces of software. They provide an
 interface to define logic, render graphics, and access system resources
 like audio and input, as well as providing a cross-platform abstraction
@@ -38,6 +24,14 @@ <h1 id="design">Design</h1>
 <img src="./brenta-picture.png" alt="high-level-overview" />
 <figcaption aria-hidden="true">high-level-overview</figcaption>
 </figure>
+<p>Brenta's its development has been more iterative than meticulously
+designed. I rewrote huge parts of the engine many many times, to the
+point where I am not scared to do big refactoring anymore - that is just
+routine - and I know I am deemed to repeat this process again. But
+through these many refactoring, the API reached a point where all
+objects work well together and you can reason about them through what I
+call the "architecture" or "design" of the engine. This is what I aim to
+describe in this documents.</p>
 <p>I wanted to write my own graphics engine primarily because I was
 curious to understand how these big systems are designed and
 implemented, and as a programming exercise / learning experience. The
@@ -89,11 +83,11 @@ <h2 id="renderer">Renderer</h2>
 uses rasterization, which means projecting each surface to the screen
 and calculating the color of each pixel by interpolating each one of
 them (parallelized on the GPU).</p>
-<p>This “projection” is achieved by multiplying together three matrices:
+<p>This "projection" is achieved by multiplying together three matrices:
 the <code>model</code> or <code>world</code> matrix which translates a
 vertex to its position in world space, the <code>view</code> matrix
 which shift and rotates the world based on the camera position (If the
-camera moves 5 feet to the right, it’s mathematically the same as moving
+camera moves 5 feet to the right, it&#x2019;s mathematically the same as moving
 the entire world 5 feet to the left), and <code>projection</code> matrix
 which applies perspective and field-of-view; this ultimately maps the
 vertices inside a cube called the Canonical Cube where the GPU can work
@@ -104,7 +98,7 @@ <h2 id="renderer">Renderer</h2>
 integrate other methods.</p>
 <h2 id="scene">Scene</h2>
 <p>There are many ways to define a scene. Brenta supports both the
-scene-graph architecture, commonly used in Godot, Unity and Unreal, and
+node-graph architecture, commonly used in Godot, Unity and Unreal, and
 the ECS (Entity Component System) architecture like in <a
 href="https://github.com/bevyengine/bevy/">Bevy</a>.</p>
 <h3 id="scene-graph">Scene graph</h3>