LibGL: Implement glLightf{v} and fix gl.h prototype

This implements the `glLightf{v}` family of functions used to set
lighting parameters per light in the GL. It also fixes an incorrect
prototype for the user exposed version of `glLightf{v}` in which
`params` was not marked as `const`.

Userland/Libraries/LibGL/GL/gl.h

@@ -571,7 +571,7 @@ GLAPI void glFogi(GLenum pname, GLint param);
 GLAPI void glPixelStorei(GLenum pname, GLint param);
 GLAPI void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
 GLAPI void glLightf(GLenum light, GLenum pname, GLfloat param);
-GLAPI void glLightfv(GLenum light, GLenum pname, GLfloat* param);
+GLAPI void glLightfv(GLenum light, GLenum pname, GLfloat const* param);
 GLAPI void glLightModelf(GLenum pname, GLfloat param);
 GLAPI void glLightModelfv(GLenum pname, GLfloat const* params);
 GLAPI void glLightModeli(GLenum pname, GLint param);

Userland/Libraries/LibGL/GLContext.h

@@ -121,6 +121,8 @@ class GLContext {
  virtual void gl_rect(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) = 0;
  virtual void gl_tex_gen(GLenum coord, GLenum pname, GLint param) = 0;
  virtual void gl_tex_gen_floatv(GLenum coord, GLenum pname, GLfloat const* params) = 0;
+ virtual void gl_lightf(GLenum light, GLenum pname, GLfloat param) = 0;
+ virtual void gl_lightfv(GLenum light, GLenum pname, GLfloat const* params) = 0;
 
  virtual void present() = 0;
 };

Userland/Libraries/LibGL/GLLights.cpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2021, Stephan Unverwerth <[email protected]>
  * Copyright (c) 2021, Jelle Raaijmakers <[email protected]>
+ * Copyright (c) 2022, Jesse Buhagiar <[email protected]>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -19,14 +20,12 @@ void glColorMaterial(GLenum face, GLenum mode)
 
 void glLightf(GLenum light, GLenum pname, GLfloat param)
 {
- // FIXME: implement
- dbgln_if(GL_DEBUG, "glLightf({}, {}, {}): unimplemented", light, pname, param);
+ g_gl_context->gl_lightf(light, pname, param);
 }
 
-void glLightfv(GLenum light, GLenum pname, GLfloat* param)
+void glLightfv(GLenum light, GLenum pname, GLfloat const* param)
 {
- // FIXME: implement
- dbgln_if(GL_DEBUG, "glLightfv({}, {}, {}): unimplemented", light, pname, param);
+ g_gl_context->gl_lightfv(light, pname, param);
 }
 
 void glLightModelf(GLenum pname, GLfloat param)

Userland/Libraries/LibGL/SoftwareGLContext.cpp

@@ -63,6 +63,17 @@ SoftwareGLContext::SoftwareGLContext(Gfx::Bitmap& frontbuffer)
 {
  m_texture_units.resize(m_device_info.num_texture_units);
  m_active_texture_unit = &m_texture_units[0];
+
+ // Query the number lights from the device and set set up their state
+ // locally in the GL
+ m_light_states.resize(m_device_info.num_lights);
+
+ // Set-up light0's state, as it has a different default state
+ // to the other lights, as per the OpenGL 1.5 spec
+ auto& light0 = m_light_states.at(0);
+ light0.diffuse_intensity = { 1.0f, 1.0f, 1.0f, 1.0f };
+ light0.specular_intensity = { 1.0f, 1.0f, 1.0f, 1.0f };
+ m_light_state_is_dirty = true;
 }
 
 Optional<ContextParameter> SoftwareGLContext::get_context_parameter(GLenum name)
@@ -2839,6 +2850,7 @@ void SoftwareGLContext::sync_device_config()
 {
  sync_device_sampler_config();
  sync_device_texcoord_config();
+ sync_light_state();
 }
 
 void SoftwareGLContext::sync_device_sampler_config()
@@ -2958,6 +2970,34 @@ void SoftwareGLContext::sync_device_sampler_config()
  }
 }
 
+void SoftwareGLContext::sync_light_state()
+{
+ if (!m_light_state_is_dirty)
+ return;
+
+ m_light_state_is_dirty = false;
+
+ for (auto light_id = 0u; light_id < SoftGPU::NUM_LIGHTS; light_id++) {
+ SoftGPU::Light light;
+ auto const& current_light_state = m_light_states.at(light_id);
+
+ light.is_enabled = current_light_state.is_enabled;
+ light.ambient_intensity = current_light_state.ambient_intensity;
+ light.diffuse_intensity = current_light_state.diffuse_intensity;
+ light.specular_intensity = current_light_state.specular_intensity;
+ light.position = current_light_state.position;
+ light.spotlight_direction = current_light_state.spotlight_direction;
+ light.spotlight_exponent = current_light_state.spotlight_exponent;
+ light.spotlight_cutoff_angle = current_light_state.spotlight_cutoff_angle;
+ light.spotlight_cutoff_angle_rads = current_light_state.spotlight_cutoff_angle_rads;
+ light.constant_attenuation = current_light_state.constant_attenuation;
+ light.linear_attenuation = current_light_state.linear_attenuation;
+ light.quadratic_attenuation = current_light_state.quadratic_attenuation;
+
+ m_rasterizer.set_light_state(light_id, light);
+ }
+}
+
 void SoftwareGLContext::sync_device_texcoord_config()
 {
  if (!m_texcoord_generation_dirty)
@@ -3019,4 +3059,89 @@ void SoftwareGLContext::sync_device_texcoord_config()
  m_rasterizer.set_options(options);
 }
 
+void SoftwareGLContext::gl_lightf(GLenum light, GLenum pname, GLfloat param)
+{
+ APPEND_TO_CALL_LIST_AND_RETURN_IF_NEEDED(gl_lightf, light, pname, param);
+
+ RETURN_WITH_ERROR_IF(m_in_draw_state, GL_INVALID_OPERATION);
+ RETURN_WITH_ERROR_IF(light < GL_LIGHT0 || light >= (GL_LIGHT0 + m_rasterizer.info().num_lights), GL_INVALID_ENUM);
+ RETURN_WITH_ERROR_IF(!(pname == GL_CONSTANT_ATTENUATION || pname == GL_LINEAR_ATTENUATION || pname == GL_QUADRATIC_ATTENUATION || pname != GL_SPOT_EXPONENT || pname != GL_SPOT_CUTOFF), GL_INVALID_ENUM);
+
+ auto& light_state = m_light_states.at(light - GL_LIGHT0);
+
+ switch (pname) {
+ case GL_CONSTANT_ATTENUATION:
+ light_state.constant_attenuation = param;
+ break;
+ case GL_LINEAR_ATTENUATION:
+ light_state.linear_attenuation = param;
+ break;
+ case GL_QUADRATIC_ATTENUATION:
+ light_state.quadratic_attenuation = param;
+ break;
+ case GL_SPOT_EXPONENT:
+ light_state.spotlight_exponent = param;
+ break;
+ case GL_SPOT_CUTOFF:
+ light_state.spotlight_cutoff_angle = param;
+ light_state.spotlight_cutoff_angle_rads = param * (AK::Pi<float> / 180.0f);
+ break;
+ default:
+ VERIFY_NOT_REACHED();
+ }
+
+ m_light_state_is_dirty = true;
+}
+
+void SoftwareGLContext::gl_lightfv(GLenum light, GLenum pname, GLfloat const* params)
+{
+ APPEND_TO_CALL_LIST_AND_RETURN_IF_NEEDED(gl_lightfv, light, pname, params);
+ RETURN_WITH_ERROR_IF(m_in_draw_state, GL_INVALID_OPERATION);
+ RETURN_WITH_ERROR_IF(light < GL_LIGHT0 || light >= (GL_LIGHT0 + m_rasterizer.info().num_lights), GL_INVALID_ENUM);
+ RETURN_WITH_ERROR_IF(!(pname == GL_AMBIENT || pname == GL_DIFFUSE || pname == GL_SPECULAR || pname == GL_POSITION || pname == GL_CONSTANT_ATTENUATION || pname == GL_LINEAR_ATTENUATION || pname == GL_QUADRATIC_ATTENUATION || pname == GL_SPOT_CUTOFF || pname == GL_SPOT_EXPONENT || pname == GL_SPOT_DIRECTION), GL_INVALID_ENUM);
+
+ auto& light_state = m_light_states.at(light - GL_LIGHT0);
+
+ switch (pname) {
+ case GL_AMBIENT:
+ light_state.ambient_intensity = { params[0], params[1], params[2], params[3] };
+ break;
+ case GL_DIFFUSE:
+ light_state.diffuse_intensity = { params[0], params[1], params[2], params[3] };
+ break;
+ case GL_SPECULAR:
+ light_state.specular_intensity = { params[0], params[1], params[2], params[3] };
+ break;
+ case GL_POSITION:
+ light_state.position = { params[0], params[1], params[2], params[3] };
+ light_state.position = m_model_view_matrix * light_state.position;
+ break;
+ case GL_CONSTANT_ATTENUATION:
+ light_state.constant_attenuation = *params;
+ break;
+ case GL_LINEAR_ATTENUATION:
+ light_state.linear_attenuation = *params;
+ break;
+ case GL_QUADRATIC_ATTENUATION:
+ light_state.quadratic_attenuation = *params;
+ break;
+ case GL_SPOT_EXPONENT:
+ light_state.spotlight_exponent = *params;
+ break;
+ case GL_SPOT_CUTOFF:
+ light_state.spotlight_cutoff_angle = *params;
+ light_state.spotlight_cutoff_angle_rads = *params * (AK::Pi<float> / 180.0f);
+ break;
+ case GL_SPOT_DIRECTION: {
+ FloatVector4 direction_vector = { params[0], params[1], params[2], 0.0f };
+ direction_vector = m_model_view_matrix * direction_vector;
+ light_state.spotlight_direction = { direction_vector.x(), direction_vector.y(), direction_vector.z() };
+ break;
+ }
+ default:
+ VERIFY_NOT_REACHED();
+ }
+
+ m_light_state_is_dirty = true;
+}
 }

Userland/Libraries/LibGL/SoftwareGLContext.h

@@ -23,6 +23,7 @@
 #include <LibGfx/Vector3.h>
 #include <LibSoftGPU/Clipper.h>
 #include <LibSoftGPU/Device.h>
+#include <LibSoftGPU/Light/Light.h>
 #include <LibSoftGPU/Vertex.h>
 
 namespace GL {
@@ -136,13 +137,16 @@ class SoftwareGLContext : public GLContext {
  virtual void gl_rect(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) override;
  virtual void gl_tex_gen(GLenum coord, GLenum pname, GLint param) override;
  virtual void gl_tex_gen_floatv(GLenum coord, GLenum pname, GLfloat const* params) override;
+ virtual void gl_lightf(GLenum light, GLenum pname, GLfloat param) override;
+ virtual void gl_lightfv(GLenum light, GLenum pname, GLfloat const* params) override;
 
  virtual void present() override;
 
 private:
  void sync_device_config();
  void sync_device_sampler_config();
  void sync_device_texcoord_config();
+ void sync_light_state();
 
  template<typename T>
  T* store_in_listing(T value)
@@ -286,6 +290,7 @@ class SoftwareGLContext : public GLContext {
  SoftGPU::Device m_rasterizer;
  SoftGPU::DeviceInfo const m_device_info;
  bool m_sampler_config_is_dirty { true };
+ bool m_light_state_is_dirty { true };
 
  struct Listing {
 
@@ -365,7 +370,9 @@ class SoftwareGLContext : public GLContext {
  decltype(&SoftwareGLContext::gl_tex_gen_floatv),
  decltype(&SoftwareGLContext::gl_fogf),
  decltype(&SoftwareGLContext::gl_fogfv),
- decltype(&SoftwareGLContext::gl_fogi)>;
+ decltype(&SoftwareGLContext::gl_fogi),
+ decltype(&SoftwareGLContext::gl_lightf),
+ decltype(&SoftwareGLContext::gl_lightfv)>;
 
  using ExtraSavedArguments = Variant<
  FloatMatrix4x4>;
@@ -419,6 +426,8 @@ class SoftwareGLContext : public GLContext {
  bool m_lighting_enabled { false };
  FloatVector4 m_light_model_ambient { 0.2f, 0.2f, 0.2f, 1.0f };
  GLfloat m_light_model_two_side { 0.0f };
+
+ Vector<SoftGPU::Light> m_light_states;
 };
 
 }

Userland/Libraries/LibSoftGPU/Device.cpp

@@ -1004,4 +1004,9 @@ void Device::set_sampler_config(unsigned sampler, SamplerConfig const& config)
  m_samplers[sampler].set_config(config);
 }
 
+void Device::set_light_state(unsigned int light_id, Light const& light)
+{
+ m_lights.at(light_id) = light;
+}
+
 }

Userland/Libraries/LibSoftGPU/Device.h

@@ -22,6 +22,7 @@
 #include <LibSoftGPU/Enums.h>
 #include <LibSoftGPU/Image.h>
 #include <LibSoftGPU/ImageFormat.h>
+#include <LibSoftGPU/Light/Light.h>
 #include <LibSoftGPU/Sampler.h>
 #include <LibSoftGPU/Triangle.h>
 #include <LibSoftGPU/Vertex.h>
@@ -92,6 +93,7 @@ class Device final {
  NonnullRefPtr<Image> create_image(ImageFormat, unsigned width, unsigned height, unsigned depth, unsigned levels, unsigned layers);
 
  void set_sampler_config(unsigned, SamplerConfig const&);
+ void set_light_state(unsigned, Light const&);
 
 private:
  void draw_statistics_overlay(Gfx::Bitmap&);
@@ -112,6 +114,7 @@ class Device final {
  Array<Sampler, NUM_SAMPLERS> m_samplers;
  Vector<size_t> m_enabled_texture_units;
  AlphaBlendFactors m_alpha_blend_factors;
+ Array<Light, NUM_LIGHTS> m_lights;
 };
 
 }

Userland/Libraries/LibSoftGPU/Light/Light.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022, Jesse Buhagiar <[email protected]>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <LibGfx/Vector3.h>
+#include <LibGfx/Vector4.h>
+
+namespace SoftGPU {
+
+struct Light {
+ bool is_enabled { false };
+
+ // According to the OpenGL 1.5 specification, page 56, all of the parameters
+ // for the following data members (positions, colors, and reals) are all
+ // floating point.
+ Vector4<float> ambient_intensity { 0.0f, 0.0f, 0.0f, 1.0f };
+ Vector4<float> diffuse_intensity { 0.0f, 0.0f, 0.0f, 1.0f };
+ Vector4<float> specular_intensity { 0.0f, 0.0f, 0.0f, 1.0f };
+ Vector4<float> position { 0.0f, 0.0f, 1.0f, 0.0f };
+ Vector3<float> spotlight_direction { 0.0f, 0.0f, -1.0f };
+
+ float spotlight_exponent { 0.0f };
+ float spotlight_cutoff_angle { 180.0f };
+ float constant_attenuation { 1.0f }; // This is referred to `k0i` in the OpenGL spec
+ float linear_attenuation { 0.0f }; // This is referred to `k1i` in the OpenGL spec
+ float quadratic_attenuation { 0.0f }; // This is referred to `k2i` in the OpenGL spec
+
+ float spotlight_cutoff_angle_rads { AK::Pi<float> / 180.0f };
+};
+
+}