Light test 1

include/JGL/types/Light.h

@@ -11,6 +11,7 @@ namespace JGL {
     class SpotLight;
 }
 
+// TODO this can be consolidated.
 class JGL::LightBase {
 protected:
     /* The 4th number represents whether the light is a positional light.
@@ -44,12 +45,13 @@ public:
 /// Omni-directional lights.
 class JGL::PointLight : public LightBase {
 public:
-    [[nodiscard]] float GetAttenuationAtPosition(const Vector3& pos) const override;
+    [[nodiscard]] float GetAttenuationAtPosition(const Vector3& pos) const final;
 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);
 };
 
 /// Lights which only effect things in a given cone.
+// TODO get attenuation at position for this.
 class JGL::SpotLight : public LightBase {
 protected:
     Matrix3x3 orientation;

main.cpp

@@ -135,12 +135,13 @@ public:
 
     EulerAngleXYZ textAngle = {0,0,0};
     float fov = 90;
+    u8 pulse = 0;
     float sprite_radians = 0;
     bool fov_increasing = true;
     int blit_pos = 0;
 
     void display() {
-
+        pulse++;
         float dt = GetDeltaTime();
 
         JGL::Update(GetSize());
@@ -165,7 +166,7 @@ public:
         camera->render();
         // All 3D elements of the scene and JGL elements *must* be rendered before the 2D stuff
         /* if rendering to screen space directly. */
-
+        auto test_light = PointLight({2,1,2}, {pulse,pulse,pulse, 255}, {0, 0, 0, 255}, {0,0,0}, 1);
         // If a 3D object has transparency. The things you'd like to see through it must be drawn before.
         J3D::Begin();
             J3D::DrawLine(Colors::Red, {-0.33,-0.125,1}, {-1,-0.125,1});
@@ -174,6 +175,7 @@ public:
             //J3D::WireframeSphere(Colors::Green, {0,0,0.5f}, 0.25f, 1, 128, 128);
             Sphere sphere = {{0,0, 0.5f}, 0.2125};
             J3D::BatchWireframeRevoSphere(Colors::Green, &sphere, 1, 1, 16, 16, true);
+            J3D::RequiredLight(&test_light);
             J3D::FillAABB(Colors::Whites::AliceBlue, {0,0,0.5f}, {0.1f, 0.1f, 0.1f});
             J3D::WireframeAABB(Colors::Gray, {0,0,0.5f}, {0.11f, 0.06f, 0.11f});
 
@@ -311,7 +313,7 @@ int main(int argc, char** argv) {
     window->Open();
     window->initGL();
     window->SetResizable(true);
-    window->SetVsyncEnabled(false);
+    window->SetVsyncEnabled(true);
     
     ReWindow::Logger::Error.EnableConsole(false);
     ReWindow::Logger::Warning.EnableConsole(false);

src/internals/internals.cpp

@@ -28,20 +28,21 @@ void JGL::J3D::SelectLights(const Vector3& position) {
             result[required_light_count++] = light_influence[i].second;
     }
 
+    glEnable(GL_LIGHTING);
     for (unsigned int i = 0; i < result.size(); i++) {
         // Terminate early if we have less than 8 lights.
         if (!result[i])
             break;
 
-        Vector4 ambient = { result[i]->GetAmbient().RN(), result[i]->GetAmbient().BN(), result[i]->GetAmbient().GN(), result[i]->GetAmbient().AN() };
-        Vector4 diffuse = { result[i]->GetDiffuse().RN(), result[i]->GetDiffuse().BN(), result[i]->GetDiffuse().GN(), result[i]->GetDiffuse().AN() };
-        Vector4 specular = { result[i]->GetSpecular().RN(), result[i]->GetSpecular().BN(), result[i]->GetSpecular().GN(), result[i]->GetSpecular().AN() };
+        Vector4 ambient = { result[i]->GetAmbient().RN(), result[i]->GetAmbient().GN(), result[i]->GetAmbient().BN(), result[i]->GetAmbient().AN() };
+        Vector4 diffuse = { result[i]->GetDiffuse().RN(), result[i]->GetDiffuse().GN(), result[i]->GetDiffuse().BN(), result[i]->GetDiffuse().AN() };
+        Vector4 specular = { result[i]->GetSpecular().RN(), result[i]->GetSpecular().GN(), result[i]->GetSpecular().BN(), result[i]->GetSpecular().AN() };
         GLenum current_light = GL_LIGHT0 + i;
 
         glEnable(GL_LIGHT0 + i);
+        glLightfv(current_light, GL_POSITION, result[i]->GetPosition().ptr());
 
         // How the light will affect different materials.
-        glLightfv(current_light, GL_POSITION, result[i]->GetPosition().ptr());
         glLightfv(current_light, GL_AMBIENT, ambient.ptr());
         glLightfv(current_light, GL_DIFFUSE, diffuse.ptr());
         glLightfv(current_light, GL_SPECULAR, specular.ptr());
@@ -51,4 +52,41 @@ void JGL::J3D::SelectLights(const Vector3& position) {
         glLightf(current_light, GL_LINEAR_ATTENUATION, result[i]->GetLinearAttenuation());
         glLightf(current_light, GL_QUADRATIC_ATTENUATION, result[i]->GetQuadraticAttenuation());
     }
-}
+}
+
+void JGL::J3D::ResetLights() {
+    Vector4 position = {0, 0, 1, 0};
+    Vector4 ambient = {0, 0, 0, 1};
+    Vector4 diffuse_light0 = {1,1,1,1};
+    Vector4 diffuse = {0,0,0,1};
+    Vector4 specular_light0 = {1,1,1,1};
+    Vector4 specular = {0,0,0,1};
+    Vector3 spot_direction = {0.0, 0.0, -1.0};
+
+    for (unsigned int i = 0; i < 8; i++) {
+        GLenum current_light = GL_LIGHT0 + i;
+
+        glLightfv(current_light, GL_POSITION, position.ptr());
+        glLightfv(current_light, GL_AMBIENT, ambient.ptr());
+        glLightf(current_light, GL_CONSTANT_ATTENUATION, 1);
+        glLightf(current_light, GL_LINEAR_ATTENUATION, 0);
+        glLightf(current_light, GL_QUADRATIC_ATTENUATION, 0);
+        glLightf(current_light, GL_SPOT_CUTOFF, 180.0);
+        glLightfv(current_light, GL_SPOT_DIRECTION, spot_direction.ptr());
+        glLightf(current_light, GL_SPOT_EXPONENT, 0.0);
+        glLightfv(current_light, GL_DIFFUSE, (i == 0 ? diffuse_light0.ptr() : diffuse.ptr()));
+        glLightfv(current_light, GL_SPECULAR, (i == 0 ? specular_light0.ptr() : specular.ptr()));
+        glDisable(current_light);
+    }
+    glDisable(GL_LIGHTING);
+}
+
+bool JGL::J3D::UsingLighting() {
+    if (!optional_lights.empty())
+        return true;
+
+    for (unsigned int i = 0; i < required_lights.size(); i++)
+        if (required_lights[i])
+            return true;
+    return false;
+}

src/internals/internals.h

@@ -47,5 +47,10 @@ namespace JGL::J3D {
     inline std::vector<const LightBase*> optional_lights;
     inline float far_plane = 0;
     inline float fov = 0;
+    // Enables lighting and selects the correct lights to use.
     void SelectLights(const Vector3& position);
+    // Resets the GL lights to default and disables them. Then, disables lighting.
+    void ResetLights();
+    [[nodiscard]] bool UsingLighting();
+
 }

src/renderer/J3D.cpp

@@ -417,7 +417,14 @@ void JGL::J3D::BatchFillAABB(const Color4& color, const AABB* boxes, const size_
         glPushMatrix();
         glTranslatef(center.x, center.y, center.z);
         glScalef(delta.x, delta.y, delta.z);
+        bool using_lights = false;
+        if (UsingLighting())
+            SelectLights(center),
+            using_lights = true;
         glDrawArrays(GL_QUAD_STRIP, 0, ShapeCache::cube_vertex_data->GetLength());
+        if (using_lights)
+            ResetLights();
+
         glPopMatrix();
     }
     glColor4fv(OpenGLState::oldColor);