mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-24 02:12:09 -05:00
Code Issues Projects Releases Packages Wiki Activity
serenity/Userland/Libraries/LibGL/GLContext.h

71 lines
3.1 KiB
C
Raw Normal View History

LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
/*
* Copyright (c) 2021, Jesse Buhagiar <jooster669@gmail.com>
Everywhere: Use s.unverwerth@serenityos.org :^)
2021-05-29 12:38:28 +02:00
* Copyright (c) 2021, Stephan Unverwerth <s.unverwerth@serenityos.org>
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include "GL/gl.h"
#include <AK/OwnPtr.h>
LibGL: Add software rasterizer This is based mostly on Fabian "ryg" Giesen's 2011 blog series "A trip through the Graphics Pipeline" and Scratchapixel's "Rasterization: a Practical Implementation". The rasterizer processes triangles in grid aligned 16x16 pixel blocks, calculates barycentric coordinates and edge derivatives and interpolates bilinearly across each block. This will theoretically allow for better utilization of modern processor features such as SMT and SIMD, as opposed to a classic scanline based triangle rasterizer. This serves as a starting point to get something on the screen. In the future we might look into properly pipelining the main loop to make the rasterizer more flexible, enabling us to enable/disable certain features at the block rather than the pixel level.
2021-04-24 01:57:01 +02:00
#include <LibGfx/Bitmap.h>
LibGL: Impement glLoadMatrixf and underlying function
2021-04-24 22:43:42 +10:00
#include <LibGfx/Matrix4x4.h>
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
namespace GL {
class GLContext {
public:
LibGL: Add software rasterizer This is based mostly on Fabian "ryg" Giesen's 2011 blog series "A trip through the Graphics Pipeline" and Scratchapixel's "Rasterization: a Practical Implementation". The rasterizer processes triangles in grid aligned 16x16 pixel blocks, calculates barycentric coordinates and edge derivatives and interpolates bilinearly across each block. This will theoretically allow for better utilization of modern processor features such as SMT and SIMD, as opposed to a classic scanline based triangle rasterizer. This serves as a starting point to get something on the screen. In the future we might look into properly pipelining the main loop to make the rasterizer more flexible, enabling us to enable/disable certain features at the block rather than the pixel level.
2021-04-24 01:57:01 +02:00
virtual ~GLContext();
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual void gl_begin(GLenum mode) = 0;
virtual void gl_clear(GLbitfield mask) = 0;
virtual void gl_clear_color(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) = 0;
LibGL: Add supporting code for depth buffer This adds glClearDepth() and new caps for enabling and disabling the depth buffer with glEnable() and glDisable()
2021-05-06 23:17:35 +02:00
virtual void gl_clear_depth(GLdouble depth) = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual void gl_color(GLdouble r, GLdouble g, GLdouble b, GLdouble a) = 0;
LibGL: Add Texture Name Allocation Texture names can now be allocated via `glGenTextures` and deallocated via `glDeleteTextures`.
2021-05-10 07:52:39 +10:00
virtual void gl_delete_textures(GLsizei n, const GLuint* textures) = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual void gl_end() = 0;
virtual void gl_frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) = 0;
LibGL: Add Texture Name Allocation Texture names can now be allocated via `glGenTextures` and deallocated via `glDeleteTextures`.
2021-05-10 07:52:39 +10:00
virtual void gl_gen_textures(GLsizei n, GLuint* textures) = 0;
LibGL: Implement glGetError and underlying function This implements `glGetError` and correctly sets the state machine's error macro (similar to LibC `errno`) when an invalid operation is performed. This is reset on completion of a successful operation.
2021-04-23 23:48:28 +10:00
virtual GLenum gl_get_error() = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual GLubyte* gl_get_string(GLenum name) = 0;
virtual void gl_load_identity() = 0;
LibGL: Impement glLoadMatrixf and underlying function
2021-04-24 22:43:42 +10:00
virtual void gl_load_matrix(const FloatMatrix4x4& matrix) = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual void gl_matrix_mode(GLenum mode) = 0;
LibGL: Implement glOrtho and underlying functions
2021-04-24 17:40:15 +04:30
virtual void gl_ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual void gl_push_matrix() = 0;
virtual void gl_pop_matrix() = 0;
virtual void gl_rotate(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) = 0;
LibGL: Implement glScalef
2021-04-24 22:11:48 +10:00
virtual void gl_scale(GLdouble x, GLdouble y, GLdouble z) = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
virtual void gl_translate(GLdouble x, GLdouble y, GLdouble z) = 0;
virtual void gl_vertex(GLdouble x, GLdouble y, GLdouble z, GLdouble w) = 0;
virtual void gl_viewport(GLint x, GLint y, GLsizei width, GLsizei height) = 0;
LibGL: Add back face culling functions Adds all needed functions to support back face culling and implements back face culling in the SoftwareGLContext.
2021-04-24 12:09:56 +02:00
virtual void gl_enable(GLenum) = 0;
virtual void gl_disable(GLenum) = 0;
virtual void gl_front_face(GLenum) = 0;
virtual void gl_cull_face(GLenum) = 0;
LibGL: Implement glGenLists and a few friends This commit implements glGenLists(), glNewList(), glDeleteLists(), and glCallList(). The 'compiled' records are implemented as a vector of member function pointers and tuples containing their arguments, and a mechanism is implemented to allow the recorded calls to copy-capture values from the time of the call; this is currently only used with glLoadMatrix.
2021-05-09 08:25:15 +04:30
virtual GLuint gl_gen_lists(GLsizei range) = 0;
virtual void gl_call_list(GLuint list) = 0;
virtual void gl_delete_lists(GLuint list, GLsizei range) = 0;
virtual void gl_end_list(void) = 0;
virtual void gl_new_list(GLuint list, GLenum mode) = 0;
LibGL: Implement glFlush() and glFinish()
2021-05-14 21:47:25 +02:00
virtual void gl_flush() = 0;
virtual void gl_finish() = 0;
LibGL: Add defines and stubs for glBlendFunc()
2021-05-15 22:45:05 +02:00
virtual void gl_blend_func(GLenum src_factor, GLenum dst_factor) = 0;
LibGL: Implement glShadeModel() This turns off interpolation of vertex colors when GL_FLAT is selected.
2021-05-16 14:05:13 +02:00
virtual void gl_shade_model(GLenum mode) = 0;
LibGL: Implement glAlphaFunc() This implements glAlphaFunc() for setting alpha test func and ref value and also allows enabling and disabling GL_ALPHA_TEST
2021-05-16 16:43:09 +02:00
virtual void gl_alpha_func(GLenum func, GLclampf ref) = 0;
LibGL: Implement glHint()
2021-05-20 23:20:23 +02:00
virtual void gl_hint(GLenum target, GLenum mode) = 0;
LibGL: Implement glReadBuffer()
2021-05-24 15:24:49 +02:00
virtual void gl_read_buffer(GLenum mode) = 0;
LibGL: Implement glReadPixels() stub with argument validation
2021-05-24 16:11:06 +02:00
virtual void gl_read_pixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) = 0;
LibGL: Implement Texture State Management Some very primitive Texture State management. Data can now be uploaded to textures.
2021-05-13 22:18:17 +10:00
virtual void gl_tex_image_2d(GLenum target, GLint level, GLint internal_format, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* data) = 0;
LibGL: Implement glTexCoord2f
2021-05-23 20:38:18 +10:00
virtual void gl_tex_coord(GLfloat s, GLfloat t, GLfloat r, GLfloat q) = 0;
LibGL: Implement glBindTexture() Textures are now initialized with a nullptr upon generation. They are only actually created once they are bound to a target. Currently only the GL_TEXTURE_2D target is supported. The software rasterizer now allows rendering with or without a bound TEXTURE_2D.
2021-05-30 00:15:51 +02:00
virtual void gl_bind_texture(GLenum target, GLuint texture) = 0;
LibGL: Add software rasterizer This is based mostly on Fabian "ryg" Giesen's 2011 blog series "A trip through the Graphics Pipeline" and Scratchapixel's "Rasterization: a Practical Implementation". The rasterizer processes triangles in grid aligned 16x16 pixel blocks, calculates barycentric coordinates and edge derivatives and interpolates bilinearly across each block. This will theoretically allow for better utilization of modern processor features such as SMT and SIMD, as opposed to a classic scanline based triangle rasterizer. This serves as a starting point to get something on the screen. In the future we might look into properly pipelining the main loop to make the rasterizer more flexible, enabling us to enable/disable certain features at the block rather than the pixel level.
2021-04-24 01:57:01 +02:00
virtual void present() = 0;
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
};
LibGL: Add software rasterizer This is based mostly on Fabian "ryg" Giesen's 2011 blog series "A trip through the Graphics Pipeline" and Scratchapixel's "Rasterization: a Practical Implementation". The rasterizer processes triangles in grid aligned 16x16 pixel blocks, calculates barycentric coordinates and edge derivatives and interpolates bilinearly across each block. This will theoretically allow for better utilization of modern processor features such as SMT and SIMD, as opposed to a classic scanline based triangle rasterizer. This serves as a starting point to get something on the screen. In the future we might look into properly pipelining the main loop to make the rasterizer more flexible, enabling us to enable/disable certain features at the block rather than the pixel level.
2021-04-24 01:57:01 +02:00
OwnPtr<GLContext> create_context(Gfx::Bitmap&);
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 22:58:01 +11:00
void make_context_current(GLContext*);
}
Reference in a new issue Copy permalink