RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 20:07:35 +00:00
Code Issues Activity Actions

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

Browse source 
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`.
This commit is contained in:
Jesse Buhagiar 2022-01-08 01:41:46 +11:00 • committed by Linus Groh
parent 192befa84b
commit bf294612a7
8 changed files with 185 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Userland/Libraries/LibGL/GL/gl.h
View file

@ -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);

2
Userland/Libraries/LibGL/GLContext.h
View file

@ -121,6 +121,8 @@ public:
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;
};

9
Userland/Libraries/LibGL/GLLights.cpp
View file

@ -1,6 +1,7 @@
/*
* Copyright (c) 2021, Stephan Unverwerth <s.unverwerth@serenityos.org>
* Copyright (c) 2021, Jelle Raaijmakers <jelle@gmta.nl>
* Copyright (c) 2022, Jesse Buhagiar <jooster669@gmail.com>
*
* 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)

125
Userland/Libraries/LibGL/SoftwareGLContext.cpp
View file

@ -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;
}
}

11
Userland/Libraries/LibGL/SoftwareGLContext.h
View file

@ -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,6 +137,8 @@ public:
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;
@ -143,6 +146,7 @@ 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 @@ private:
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 @@ private:
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 @@ private:
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;
};
}

5
Userland/Libraries/LibSoftGPU/Device.cpp
View file

@ -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;
}
}

3
Userland/Libraries/LibSoftGPU/Device.h
View file

@ -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 @@ public:
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 @@ private:
Array<Sampler, NUM_SAMPLERS> m_samplers;
Vector<size_t> m_enabled_texture_units;
AlphaBlendFactors m_alpha_blend_factors;
Array<Light, NUM_LIGHTS> m_lights;
};
}

35
Userland/Libraries/LibSoftGPU/Light/Light.h Normal file
View file

@ -0,0 +1,35 @@
/*
* Copyright (c) 2022, Jesse Buhagiar <jooster669@gmail.com>
*
* 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 };
};
}