Merge pull request #60 from nightingazer/little_something

make a little demo of what possible with the engine so far

AGE/include/Age/Age.h

@@ -10,6 +10,9 @@
 #include "Age/Core/Log.h"
 #include "Age/Core/Timer.h"
 
+// Utils
+#include "Age/Utils/Random.h"
+
 // Input handling
 #include "Age/Core/Input.h"
 #include "Age/Core/KeyCodes.h"

AGE/include/Age/EntryPoint.h

@@ -9,6 +9,7 @@
 #include "Age/Core/Core.h"
 #include "Age/Core/Log.h"
 #include "Age/Debug/Instrumentor.h"
+#include "Age/Utils/Random.h"
 
 extern AGE::Application* AGE::CreateApplication();
 

AGE/src/Age/Renderer/OrthographicCameraController.cpp

@@ -12,9 +12,12 @@
 
 namespace AGE {
   OrthographicCameraController::OrthographicCameraController(float aspectRatio, bool rotation)
-      : m_AspectRatio(aspectRatio), m_Camera(
-      -m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel
-  ), m_Rotation(rotation) {
+      : m_AspectRatio(aspectRatio), m_ZoomLevel{1.0f},
+        m_Bounds{-m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel},
+        m_Camera(
+            -m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel
+        ),
+        m_Rotation(rotation) {
   }
 
   void OrthographicCameraController::OnUpdate(Timestep ts) {
@@ -79,9 +82,8 @@ namespace AGE {
 
     m_ZoomLevel -= e.YOffset() * 0.25f;
     m_ZoomLevel = std::max(m_ZoomLevel, 0.25f);
-    m_Camera.SetProjection(
-        -m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel
-    );
+    m_Bounds    = {-m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel};
+    m_Camera.SetProjection(m_Bounds.Left, m_Bounds.Right, m_Bounds.Bottom, m_Bounds.Top);
     return false;
   }
 

AGE/src/Age/Renderer/OrthographicCameraController.h

@@ -17,8 +17,16 @@
 namespace AGE {
 
   class OrthographicCameraController {
+    struct CameraBounds {
+      float Left, Right;
+      float Bottom, Top;
+
+      [[nodiscard]] inline float Width() const { return Right - Left; }
+      [[nodiscard]] inline float Height() const { return Top - Bottom; }
+    };
+
   public:
-    OrthographicCameraController(float aspectRatio, bool rotation = false);
+    explicit OrthographicCameraController(float aspectRatio, bool rotation = false);
 
     void OnUpdate(Timestep ts);
     void OnEvent(Event& e);
@@ -30,6 +38,7 @@ namespace AGE {
 
     float ZoomLevel() const { return m_ZoomLevel; }
     void SetZoomLevel(float level) { m_ZoomLevel = level; }
+    [[nodiscard]] inline CameraBounds Bounds() const { return m_Bounds; }
 
   private:
     bool OnMouseScrolled(MouseScrolledEvent& e);
@@ -39,6 +48,7 @@ namespace AGE {
     float              m_AspectRatio;
     float              m_ZoomLevel = 1.0f;
     OrthographicCamera m_Camera;
+    CameraBounds       m_Bounds;
 
     bool m_Rotation;
 

AGE/src/Age/Renderer/Renderer2D.cpp

@@ -201,7 +201,7 @@ namespace AGE {
 
     // Reset color to white if texture is corrupted to properly display error texture
     glm::vec4 vertexColor{color};
-    if (!texture->IsCorrect()) {
+    if (texture && !texture->IsCorrect()) {
       vertexColor = {1.0f, 1.0f, 1.0f, 1.0f};
     }
 
@@ -278,24 +278,24 @@ namespace AGE {
 //                                        DRAW ROTATED QUAD                                       //
 // /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void Renderer2D::DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, const float rotation, const glm::vec4& color) {
-    DrawRotatedQuad(glm::vec3{pos, 0.0f}, size, rotation, nullptr, color, 1.0f);
+  void Renderer2D::DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, const float rotationDeg, const glm::vec4& color) {
+    DrawRotatedQuad(glm::vec3{pos, 0.0f}, size, rotationDeg, nullptr, color, 1.0f);
   }
 
-  void Renderer2D::DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, const float rotation, const glm::vec4& color) {
-    DrawRotatedQuad(pos, size, rotation, nullptr, color, 1.0f);
+  void Renderer2D::DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, const float rotationDeg, const glm::vec4& color) {
+    DrawRotatedQuad(pos, size, rotationDeg, nullptr, color, 1.0f);
   }
 
-  void Renderer2D::DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, const float rotation, const Ref<Texture2D>& texture, float tillingFactor) {
-    DrawRotatedQuad(glm::vec3{pos, 0.0f}, size, rotation, nullptr, glm::vec4{1.0f}, 1.0f);
+  void Renderer2D::DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, const float rotationDeg, const Ref<Texture2D>& texture, float tillingFactor) {
+    DrawRotatedQuad(glm::vec3{pos, 0.0f}, size, rotationDeg, nullptr, glm::vec4{1.0f}, 1.0f);
   }
 
-  void Renderer2D::DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, const float rotation, const Ref<Texture2D>& texture, float tillingFactor) {
-    DrawRotatedQuad(pos, size, rotation, nullptr, glm::vec4{1.0f}, 1.0f);
+  void Renderer2D::DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, const float rotationDeg, const Ref<Texture2D>& texture, float tillingFactor) {
+    DrawRotatedQuad(pos, size, rotationDeg, nullptr, glm::vec4{1.0f}, 1.0f);
   }
 
-  void Renderer2D::DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, const float rotation, const Ref<Texture2D>& texture, const glm::vec4& color) {
-    DrawRotatedQuad(glm::vec3{pos, 0.0f}, size, rotation, nullptr, glm::vec4{1.0f}, 1.0f);
+  void Renderer2D::DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, const float rotationDeg, const Ref<Texture2D>& texture, const glm::vec4& color) {
+    DrawRotatedQuad(glm::vec3{pos, 0.0f}, size, rotationDeg, nullptr, glm::vec4{1.0f}, 1.0f);
   }
 
   void Renderer2D::DrawRotatedQuad(

AGE/src/Age/Renderer/Renderer2D.h

@@ -50,11 +50,11 @@ namespace AGE {
 
 #pragma region DrawRotatedQuad
 
-    static void DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, float rotation, const glm::vec4& color);
-    static void DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, float rotation, const glm::vec4& color);
-    static void DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, float rotation, const Ref<Texture2D>& texture, float tillingFactor = 1.0f);
-    static void DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, float rotation, const Ref<Texture2D>& texture, float tillingFactor = 1.0f);
-    static void DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, float rotation, const Ref<Texture2D>& texture, const glm::vec4& color);
+    static void DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, float rotationDeg, const glm::vec4& color);
+    static void DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, float rotationDeg, const glm::vec4& color);
+    static void DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, float rotationDeg, const Ref<Texture2D>& texture, float tillingFactor = 1.0f);
+    static void DrawRotatedQuad(const glm::vec3& pos, const glm::vec2& size, float rotationDeg, const Ref<Texture2D>& texture, float tillingFactor = 1.0f);
+    static void DrawRotatedQuad(const glm::vec2& pos, const glm::vec2& size, float rotationDeg, const Ref<Texture2D>& texture, const glm::vec4& color);
 
     /**
      * @brief Adds a rotated quad to the current batch.

AGE/src/Age/Utils/Random.cpp

@@ -0,0 +1,10 @@
+//
+// Created by alex on 1/26/23.
+//
+
+#include "Random.h"
+
+namespace AGE {
+  thread_local std::mt19937                                             Random::s_RandomEngine{std::random_device()()};
+  thread_local std::uniform_int_distribution<std::mt19937::result_type> Random::s_Distribution{};
+} // AGE

AGE/src/Age/Utils/Random.h

@@ -0,0 +1,58 @@
+//
+// Created by alex on 1/26/23.
+//
+
+#ifndef AGE_RANDOM_H
+#define AGE_RANDOM_H
+
+#include <random>
+#include <cinttypes>
+
+#include <glm/glm.hpp>
+
+namespace AGE {
+
+  class Random {
+  public:
+
+    static float Float()
+    {
+      return (float)s_Distribution(s_RandomEngine) / (float)std::numeric_limits<uint_fast32_t>::max();
+    }
+    static float Float(float min, float max) {
+      return Float() * (max - min) + min;
+    }
+
+    static uint32_t UInt() {
+      return s_Distribution(s_RandomEngine);
+    }
+    static uint32_t UInt(uint32_t min, uint32_t max) {
+      return min + (s_Distribution(s_RandomEngine) % (max - min + 1));
+    }
+
+    static glm::vec3 Vec3() {
+      return {Float(), Float(), Float()};
+    }
+    static glm::vec3 Vec3(float min, float max) {
+      return {Float(min, max), Float(min, max), Float(min, max)};
+    }
+
+    static glm::vec2 Vec2() {
+      return {Float(), Float()};
+    }
+    static glm::vec2 Vec2(float min, float max) {
+      return {Float(min, max), Float(min, max)};
+    }
+
+    static glm::vec3 InUnitSphere() {
+      return glm::normalize(Vec3(-1.0f, 1.0f));
+    }
+
+  private:
+    static thread_local std::mt19937                                             s_RandomEngine;
+    static thread_local std::uniform_int_distribution<std::mt19937::result_type> s_Distribution;
+  };
+
+} // AGE
+
+#endif //AGE_RANDOM_H

AGE/src/Platform/OpenGL/OpenGLTexture.cpp

@@ -16,7 +16,8 @@ namespace AGE {
                                                                             m_InternalFormat(
                                                                                 GL_RGBA8
                                                                             ),
-                                                                            m_DataFormat(GL_RGBA) {
+                                                                            m_DataFormat(GL_RGBA),
+                                                                            m_isCorrect{true} {
     AGE_PROFILE_FUNCTION();
 
     glCreateTextures(GL_TEXTURE_2D, 1, &m_RendererID);
@@ -29,7 +30,8 @@ namespace AGE {
   OpenGLTexture2D::OpenGLTexture2D(const age_string_t& path) : m_Path(path), m_Slot{0},
                                                                m_isBound{false},
                                                                m_InternalFormat(0),
-                                                               m_DataFormat(0) {
+                                                               m_DataFormat(0),
+                                                               m_isCorrect{true} {
     AGE_PROFILE_FUNCTION();
 
     int width, height, channels;

Sandbox/CMakeLists.txt

@@ -2,7 +2,9 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.7)
 project(AGE)
 set(CMAKE_CXX_STANDARD 23)
 
-add_executable(Sandbox src/main.cpp src/Sandbox.cpp src/Sandbox.h src/Sandbox2DLayer.cpp src/Sandbox2DLayer.h src/SandboxLayer.cpp src/SandboxLayer.h)
+file(GLOB _SANDBOX_SRCS src/*.cpp src/*.h)
+
+add_executable(Sandbox ${_SANDBOX_SRCS})
 target_link_libraries(Sandbox PUBLIC age_core)
 
 file(REMOVE_RECURSE ${CMAKE_CURRENT_BINARY_DIR}/assets)

Sandbox/src/Particle.cpp

@@ -0,0 +1,70 @@
+//
+// Created by alex on 1/25/23.
+//
+
+#include "Particle.h"
+
+void ParticleSystem::OnUpdate(AGE::Timestep ts) {
+  for (auto& particle: m_Particles) {
+    if (!particle.Active)
+      continue;
+
+    if (particle.LifeRemaining <= 0.0f) {
+      particle.Active = false;
+      continue;
+    }
+
+    particle.LifeRemaining -= ts;
+    particle.Position += particle.Velocity * ts.Seconds();
+    particle.RotationDeg += particle.RotationSpeedDeg * ts.Seconds();
+  }
+}
+
+void ParticleSystem::Render() {
+  for (auto& particle: m_Particles) {
+    if(!particle.Active)
+      continue;
+
+    float     life  = particle.LifeRemaining / particle.LifeTime;
+    glm::vec4 color = particle.ColorBegin * (1.0f - life) + particle.ColorEnd * (life);
+    float size = particle.SizeBegin * (1.0f + life) + particle.SizeEnd * (life);
+
+    AGE::Renderer2D::DrawRotatedQuad(particle.Position, glm::vec2{size}, particle.RotationDeg, color);
+  }
+}
+
+void ParticleSystem::Emit(const ParticleProps& props) {
+  if (m_NextPoolInsert == m_Particles.end())
+    m_NextPoolInsert = m_Particles.begin();
+
+  glm::vec2 velocity  = {props.Velocity.x + props.VelocityVariations * AGE::Random::Float(-1.0f, 1.0f),
+                         props.Velocity.y + props.VelocityVariations * AGE::Random::Float(-1.0f, 1.0f)};
+  float rotationSpeed = props.RotationSpeedDeg + props.RotationSpeedVariationDeg * AGE::Random::Float(-1.0f, 1.0f);
+
+  float     sizeBegin = props.SizeBegin + props.SizeVariations * AGE::Random::Float(-1.0f, 1.0f);
+  float     sizeEnd   = props.SizeEnd + props.SizeVariations * AGE::Random::Float(-1.0f, 1.0f);
+
+  glm::vec4 colorBegin = {props.ColorBegin.r + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f),
+                          props.ColorBegin.g + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f),
+                          props.ColorBegin.b + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f),
+                          props.ColorBegin.a + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f)};
+  glm::vec4 colorEnd = {props.ColorEnd.r + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f),
+                          props.ColorEnd.g + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f),
+                          props.ColorEnd.b + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f),
+                          props.ColorEnd.a + props.ColorVariations * AGE::Random::Float(-1.0f, 1.0f)};
+
+  m_NextPoolInsert->Active   = true;
+  m_NextPoolInsert->LifeRemaining = m_NextPoolInsert->LifeTime = props.LifeTime;
+
+  m_NextPoolInsert->ColorEnd   = colorBegin;
+  m_NextPoolInsert->ColorBegin = colorEnd;
+
+  m_NextPoolInsert->RotationSpeedDeg = rotationSpeed;
+  m_NextPoolInsert->RotationDeg      = 0;
+  m_NextPoolInsert->Position         = props.Position;
+  m_NextPoolInsert->SizeBegin = sizeBegin;
+  m_NextPoolInsert->SizeEnd   = sizeEnd;
+  m_NextPoolInsert->Velocity  = velocity;
+
+  m_NextPoolInsert++;
+}

Sandbox/src/Particle.h

@@ -0,0 +1,59 @@
+//
+// Created by alex on 1/25/23.
+//
+
+#ifndef AGE_PARTICLE_H
+#define AGE_PARTICLE_H
+
+#include <vector>
+
+#include "glm/glm.hpp"
+
+#include "Age/Age.h"
+
+struct ParticleProps {
+  glm::vec2 Position;
+  glm::vec2 Velocity;
+  float     VelocityVariations;
+  float     RotationSpeedDeg;
+  float     RotationSpeedVariationDeg;
+
+  glm::vec4 ColorBegin, ColorEnd;
+  float     ColorVariations;
+
+  float SizeBegin, SizeEnd;
+  float SizeVariations;
+
+  float LifeTime{1.0f};
+  float Rotation;
+};
+
+class ParticleSystem {
+public:
+  ParticleSystem(uint32_t poolSize) : m_Particles(poolSize), m_NextPoolInsert(m_Particles.begin()) {}
+
+  void OnUpdate(AGE::Timestep ts);
+  void Render();
+  void Emit(const ParticleProps& props);
+
+private:
+  struct Particle {
+    glm::vec2 Position;
+    float     RotationDeg;
+    float     RotationSpeedDeg;
+    glm::vec2 Velocity;
+    glm::vec4 ColorBegin, ColorEnd;
+    float     SizeBegin, SizeEnd;
+
+    float LifeTime{1.0f};
+    float LifeRemaining{0.0f};
+
+    bool Active{false};
+  };
+
+  std::vector<Particle>           m_Particles;
+  std::vector<Particle>::iterator m_NextPoolInsert;
+};
+
+
+#endif //AGE_PARTICLE_H

Sandbox/src/Sandbox.cpp

@@ -13,7 +13,7 @@ AGE::Application* AGE::CreateApplication() {
 
 Sandbox::Sandbox() : AGE::Application() {
   PushLayer(new Sandbox2DLayer);
-  PushOverlay(new Sandbox2DUI);
+//  PushOverlay(new Sandbox2DUI);
 }
 
 Sandbox::~Sandbox() {}