Update repositories

CMakeLists.txt

@@ -27,7 +27,7 @@ CPMAddPackage(
 
 CPMAddPackage(
         NAME ReWindow
-        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-21.zip
+        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-26.zip
 )
 
 CPMAddPackage(

include/JGL/types/Light.h

@@ -21,12 +21,27 @@ protected:
     float constant_attenuation;
     float linear_attenuation;
     float quadratic_attenuation;
+public:
+    [[nodiscard]] Vector3 GetPosition() const;
+    [[nodiscard]] Color4 GetAmbient() const;
+    [[nodiscard]] Color4 GetDiffuse() const;
+    [[nodiscard]] Color4 GetSpecular() const;
+
+    [[nodiscard]] float GetConstantAttenuation() const;
+    [[nodiscard]] float GetLinearAttenuation() const;
+    [[nodiscard]] float GetQuadraticAttenuation() const;
+public:
+    /// Runs a calculation to determine the lights influence on a given point in 3D space.
+    /// @note 0 would be no impact, 1 would be the light is at the same position.
+    [[nodiscard]] virtual float GetAttenuationAtPosition(const Vector3& pos) const { return 0; }
 public:
     virtual ~LightBase() = default;
 };
 
 /// Omni-directional lights.
 class JGL::PointLight : public LightBase {
+public:
+    [[nodiscard]] float GetAttenuationAtPosition(const Vector3& pos) const override;
 public:
     PointLight(const Vector3& position, const Color4& ambient, const Color4& diffuse, const Color4& specular, float constant_attenuation = 1, float linear_attenuation = 0, float quadratic_attenuation = 0);
 };

main.cpp

@@ -107,7 +107,7 @@ public:
     void initGL() {
         camera = new Camera;
 
-        if (!JGL::Init(getSize(), 75, 100))
+        if (!JGL::Init(GetSize(), 75, 100))
             Logger::Fatal("Initialization failed.");
 
         FreeSans = JGL::Font("assets/fonts/FreeSans.ttf");
@@ -133,7 +133,7 @@ public:
     void display() {
 
         float dt = 1.f / fps;
-        JGL::Update(getSize());
+        JGL::Update(GetSize());
 
         if (fov_increasing)
             fov += 0.025;
@@ -232,27 +232,27 @@ public:
     }
 
     void OnRefresh(float elapsed) override {
-        if (isKeyDown(Keys::RightArrow))
+        if (IsKeyDown(Keys::RightArrow))
             camera->angle.y += 45.f * elapsed;
-        if (isKeyDown(Keys::LeftArrow))
+        if (IsKeyDown(Keys::LeftArrow))
             camera->angle.y -= 45.f * elapsed;
-        if (isKeyDown(Keys::UpArrow))
+        if (IsKeyDown(Keys::UpArrow))
             camera->angle.x -= 45.f * elapsed;
-        if (isKeyDown(Keys::DownArrow))
+        if (IsKeyDown(Keys::DownArrow))
             camera->angle.x += 45.f * elapsed;
-        if (isKeyDown(Keys::Space))
+        if (IsKeyDown(Keys::Space))
             camera->position.y += 1.f * elapsed;
-        if (isKeyDown(Keys::LeftShift))
+        if (IsKeyDown(Keys::LeftShift))
             camera->position.y -= 1.f * elapsed;
 
          //This is wrong of course. Just for testing purposes.
-        if (isKeyDown(Keys::W))
+        if (IsKeyDown(Keys::W))
             camera->position.z += 1.f * elapsed;
-        if (isKeyDown(Keys::S))
+        if (IsKeyDown(Keys::S))
             camera->position.z -= 1.f * elapsed;
-        if (isKeyDown(Keys::A))
+        if (IsKeyDown(Keys::A))
             camera->position.x += 1.f * elapsed;
-        if (isKeyDown(Keys::D))
+        if (IsKeyDown(Keys::D))
             camera->position.x -= 1.f * elapsed;
 
 
@@ -265,11 +265,11 @@ public:
         int glError = glGetError();
         if (glError != GL_NO_ERROR)
             std::cout << glError << std::endl;
-        glSwapBuffers();
+        GLSwapBuffers();
     }
 
 
-    void OnMouseButtonDown(const ReWindow::WindowEvents::MouseButtonDownEvent & ev) override
+    void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent & ev) override
     {
         RWindow::OnMouseButtonDown(ev);
         a.Grab();
@@ -278,7 +278,7 @@ public:
         d.Grab();
     }
 
-    void OnMouseButtonUp(const ReWindow::WindowEvents::MouseButtonUpEvent & ev) override
+    void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent & ev) override
     {
         RWindow::OnMouseButtonUp(ev);
         a.Release();
@@ -294,16 +294,16 @@ public:
 
 int main(int argc, char** argv) {
     auto* window = new JGLDemoWindow("JGL Demo Window", 1280, 720);
-    window->setRenderer(RenderingAPI::OPENGL);
+    window->SetRenderer(RenderingAPI::OPENGL);
     window->Open();
     window->initGL();
-    window->setResizable(true);
-    window->setVsyncEnabled(false);
+    window->SetResizable(true);
+    window->SetVsyncEnabled(false);
 
-    while (window->isAlive()) {
+    while (window->IsAlive()) {
         std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
-        window->pollEvents();
-        window->refresh();
+        window->PollEvents();
+        window->Refresh();
         std::chrono::high_resolution_clock::time_point stop = std::chrono::high_resolution_clock::now();
         std::chrono::duration<float> frame_time = stop - start;
         fps = 1.0f / frame_time.count();

src/JGL.cpp

@@ -1172,6 +1172,10 @@ namespace JGL {
 // For objects that are *extremely* big, Like base level geometry, I'll have to use its collision map for this to look right. - Redacted.
 
 #pragma region J3D
+
+#pragma region internal_drawables
+#pragma endregion
+
     std::array<GLfloat, 16> OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far) {
         std::array<GLfloat, 16> result{};
         GLfloat f = 1.0f / std::tan(fovY * 0.5f * Math::Pi / 180.0f);
@@ -1183,6 +1187,14 @@ namespace JGL {
         return result;
     }
 
+    float EffectOfLightOnPointIn3DSpace(const PointLight* light, const Vector3& position) {
+        Vector3 light_pos = light->GetPosition();
+        Vector3 vector_to_position = position - light_pos;
+        float distance = vector_to_position.Length();
+
+        return 1.0f / (light->GetConstantAttenuation() + light->GetLinearAttenuation() * distance + light->GetQuadraticAttenuation() * distance * distance);
+    }
+
     void J3D::ChangeFOV(float fov) {
         j3d_fov = fov;
     }

src/types/Light.cpp

@@ -10,6 +10,14 @@ JGL::PointLight::PointLight(const Vector3& position, const Color4& ambient, cons
     this->quadratic_attenuation = quadratic_attenuation;
 }
 
+float JGL::PointLight::GetAttenuationAtPosition(const Vector3& pos) const {
+    Vector3 light_pos = {position.x, position.y, position.z};
+    Vector3 vector_to_position = pos - light_pos;
+    float distance = vector_to_position.Length();
+
+    return 1.0f / (GetConstantAttenuation() + GetLinearAttenuation() * distance + GetQuadraticAttenuation() * distance * distance);
+}
+
 JGL::SpotLight::SpotLight(const Vector3& position, const Matrix3x3& ro_mat, float cone_size_degrees, float exponent, const Color4& ambient, const Color4& diffuse, const Color4& specular,
                           float constant_attenuation, float linear_attenuation, float quadratic_attenuation) {
     this->position = Vector4(position, 1);
@@ -24,3 +32,33 @@ JGL::SpotLight::SpotLight(const Vector3& position, const Matrix3x3& ro_mat, floa
     this->linear_attenuation = linear_attenuation;
     this->quadratic_attenuation = quadratic_attenuation;
 }
+
+Vector3 JGL::LightBase::GetPosition() const {
+    return {position.x, position.y, position.z};
+}
+
+Color4 JGL::LightBase::GetAmbient() const {
+    return ambient;
+}
+
+Color4 JGL::LightBase::GetDiffuse() const {
+    return diffuse;
+}
+
+Color4 JGL::LightBase::GetSpecular() const {
+    return specular;
+}
+
+float JGL::LightBase::GetConstantAttenuation() const {
+    return constant_attenuation;
+}
+
+float JGL::LightBase::GetLinearAttenuation() const {
+    return linear_attenuation;
+}
+
+float JGL::LightBase::GetQuadraticAttenuation() const {
+    return quadratic_attenuation;
+}
+
+