Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-31 19:21:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

[OPENGL32][MESA] Downgrade Mesa library to version 2.6

Browse source 
With this commit, we now use a forked version of MESA which only supports OpenGL 1.1, like the windows implementation does.
It exposes :
  - The same pixel formats
  - The same set of extensions
  - Nothing more
All of this without taking 10% of your build time.
If you need a more modern option, look at the MESA package from Rapps, which is (and must be) maintained outside of this code tree.
CORE-7499
This commit is contained in:
Jérôme Gardou 2018-12-10 18:04:20 +01:00 • committed by Jérôme Gardou
parent 905bcf617f
commit 5f2bebf7a5
448 changed files with 56975 additions and 132249 deletions
Download patch file Download diff file Expand all files Collapse all files

557
dll/opengl/mesa/dd.h Normal file
View file

@ -0,0 +1,557 @@
/* $Id: dd.h,v 1.15 1997/12/05 04:38:28 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 2.6
* Copyright (C) 1995-1997 Brian Paul
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* $Log: dd.h,v $
* Revision 1.15 1997/12/05 04:38:28 brianp
* added ClearColorAndDepth() function pointer (David Bucciarelli)
*
* Revision 1.14 1997/11/25 03:39:41 brianp
* added TexSubImage() function pointer (David Bucciarelli)
*
* Revision 1.13 1997/10/29 02:23:54 brianp
* added UseGlobalTexturePalette() dd function (David Bucciarelli v20 3dfx)
*
* Revision 1.12 1997/10/16 02:27:53 brianp
* more comments
*
* Revision 1.11 1997/10/14 00:07:40 brianp
* added DavidB's fxmesa v19 changes
*
* Revision 1.10 1997/09/29 23:26:50 brianp
* new texture functions
*
* Revision 1.9 1997/04/29 01:31:07 brianp
* added RasterSetup() function to device driver
*
* Revision 1.8 1997/04/20 19:47:27 brianp
* added RenderVB to device driver
*
* Revision 1.7 1997/04/20 16:31:08 brianp
* added NearFar device driver function
*
* Revision 1.6 1997/04/12 12:27:31 brianp
* added QuadFunc and RectFunc
*
* Revision 1.5 1997/03/21 01:57:07 brianp
* added RendererString() function
*
* Revision 1.4 1997/02/10 19:22:47 brianp
* added device driver Error() function
*
* Revision 1.3 1997/01/16 03:34:33 brianp
* added preliminary texture mapping functions and cleaned up documentation
*
* Revision 1.2 1996/11/13 03:51:59 brianp
* updated comments
*
* Revision 1.1 1996/09/13 01:38:16 brianp
* Initial revision
*
*/
#ifndef DD_INCLUDED
#define DD_INCLUDED
/* THIS FILE ONLY INCLUDED BY types.h !!!!! */
/*
* Device Driver (DD) interface
*
*
* All device driver functions are accessed through pointers in the
* dd_function_table struct (defined below) which is stored in the GLcontext
* struct. Since the device driver is strictly accessed trough a table of
* function pointers we can:
* 1. switch between a number of different device drivers at runtime.
* 2. use optimized functions dependant on current rendering state or
* frame buffer configuration.
*
* The function pointers in the dd_function_table struct are divided into
* two groups: mandatory and optional.
* Mandatory functions have to be implemented by every device driver.
* Optional functions may or may not be implemented by the device driver.
* The optional functions provide ways to take advantage of special hardware
* or optimized algorithms.
*
* The function pointers in the dd_function_table struct are first
* initialized in the "MakeCurrent" function. The "MakeCurrent" function
* is a little different in each device driver. See the X/Mesa, GLX, or
* OS/Mesa drivers for examples.
*
* Later, Mesa may call the dd_function_table's UpdateState() function.
* This function should initialize the dd_function_table's pointers again.
* The UpdateState() function is called whenever the core (GL) rendering
* state is changed in a way which may effect rasterization. For example,
* the TriangleFunc() pointer may have to point to different functions
* depending on whether smooth or flat shading is enabled.
*
* Note that the first argument to every device driver function is a
* GLcontext *. In turn, the GLcontext->DriverCtx pointer points to
* the driver-specific context struct. See the X/Mesa or OS/Mesa interface
* for an example.
*
* For more information about writing a device driver see the ddsample.c
* file and other device drivers (xmesa[123].c, osmesa.c, etc) for examples.
*
*
* Look below in the dd_function_table struct definition for descriptions
* of each device driver function.
*
*
* In the future more function pointers may be added for glReadPixels
* glCopyPixels, etc.
*
*
* Notes:
* ------
* RGBA = red/green/blue/alpha
* CI = color index (color mapped mode)
* mono = all pixels have the same color or index
*
* The write_ functions all take an array of mask flags which indicate
* whether or not the pixel should be written. One special case exists
* in the write_color_span function: if the mask array is NULL, then
* draw all pixels. This is an optimization used for glDrawPixels().
*
* IN ALL CASES:
* X coordinates start at 0 at the left and increase to the right
* Y coordinates start at 0 at the bottom and increase upward
*
*/
/*
* Device Driver function table.
*/
struct dd_function_table {
/**********************************************************************
*** Mandatory functions: these functions must be implemented by ***
*** every device driver. ***
**********************************************************************/
const char * (*RendererString)(void);
/*
* Return a string which uniquely identifies this device driver.
* The string should contain no whitespace. Examples: "X11" "OffScreen"
* "MSWindows" "SVGA".
*/
void (*UpdateState)( GLcontext *ctx );
/*
* UpdateState() is called whenver Mesa thinks the device driver should
* update its state and/or the other pointers (such as PointsFunc,
* LineFunc, or TriangleFunc).
*/
void (*ClearIndex)( GLcontext *ctx, GLuint index );
/*
* Called whenever glClearIndex() is called. Set the index for clearing
* the color buffer.
*/
void (*ClearColor)( GLcontext *ctx, GLubyte red, GLubyte green,
GLubyte blue, GLubyte alpha );
/*
* Called whenever glClearColor() is called. Set the color for clearing
* the color buffer.
*/
void (*Clear)( GLcontext *ctx,
GLboolean all, GLint x, GLint y, GLint width, GLint height );
/*
* Clear the current color buffer. If 'all' is set the clear the whole
* buffer, else clear the region defined by (x,y,width,height).
*/
void (*Index)( GLcontext *ctx, GLuint index );
/*
* Sets current color index for drawing flat-shaded primitives.
*/
void (*Color)( GLcontext *ctx,
GLubyte red, GLubyte green, GLubyte glue, GLubyte alpha );
/*
* Sets current color for drawing flat-shaded primitives.
*/
GLboolean (*SetBuffer)( GLcontext *ctx, GLenum mode );
/*
* Selects either the front or back color buffer for reading and writing.
* mode is either GL_FRONT or GL_BACK.
*/
void (*GetBufferSize)( GLcontext *ctx,
GLuint *width, GLuint *height );
/*
* Returns the width and height of the current color buffer.
*/
/***
*** Functions for writing pixels to the frame buffer:
***/
void (*WriteColorSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y,
const GLubyte red[], const GLubyte green[],
const GLubyte blue[], const GLubyte alpha[],
const GLubyte mask[] );
/*
* Write a horizontal run of RGBA pixels.
*/
void (*WriteMonocolorSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y,
const GLubyte mask[] );
/*
* Write a horizontal run of mono-RGBA pixels.
*/
void (*WriteColorPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLubyte red[], const GLubyte green[],
const GLubyte blue[], const GLubyte alpha[],
const GLubyte mask[] );
/*
* Write an array of RGBA pixels at random locations.
*/
void (*WriteMonocolorPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLubyte mask[] );
/*
* Write an array of mono-RGBA pixels at random locations.
*/
void (*WriteIndexSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLuint index[],
const GLubyte mask[] );
/*
* Write a horizontal run of CI pixels.
*/
void (*WriteMonoindexSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y,
const GLubyte mask[] );
/*
* Write a horizontal run of mono-CI pixels.
*/
void (*WriteIndexPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLuint index[], const GLubyte mask[] );
/*
* Write a random array of CI pixels.
*/
void (*WriteMonoindexPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLubyte mask[] );
/*
* Write a random array of mono-CI pixels.
*/
/***
*** Functions to read pixels from frame buffer:
***/
void (*ReadIndexSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y, GLuint index[] );
/*
* Read a horizontal run of color index pixels.
*/
void (*ReadColorSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y,
GLubyte red[], GLubyte green[],
GLubyte blue[], GLubyte alpha[] );
/*
* Read a horizontal run of RGBA pixels.
*/
void (*ReadIndexPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] );
/*
* Read a random array of CI pixels.
*/
void (*ReadColorPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte red[], GLubyte green[],
GLubyte blue[], GLubyte alpha[],
const GLubyte mask[] );
/*
* Read a random array of RGBA pixels.
*/
/**********************************************************************
*** Optional functions: these functions may or may not be ***
*** implemented by the device driver. If the device driver ***
*** doesn't implement them it should never touch these pointers ***
*** since Mesa will either set them to NULL or point them at a ***
*** fall-back function. ***
**********************************************************************/
void (*Finish)( GLcontext *ctx );
/*
* Called whenever glFinish() is called.
*/
void (*Flush)( GLcontext *ctx );
/*
* Called whenever glFlush() is called.
*/
GLboolean (*IndexMask)( GLcontext *ctx, GLuint mask );
/*
* Implements glIndexMask() if possible, else return GL_FALSE.
*/
GLboolean (*ColorMask)( GLcontext *ctx,
GLboolean rmask, GLboolean gmask,
GLboolean bmask, GLboolean amask );
/*
* Implements glColorMask() if possible, else return GL_FALSE.
*/
GLboolean (*LogicOp)( GLcontext *ctx, GLenum op );
/*
* Implements glLogicOp() if possible, else return GL_FALSE.
*/
void (*Dither)( GLcontext *ctx, GLboolean enable );
/*
* Enable/disable dithering.
*/
void (*Error)( GLcontext *ctx );
/*
* Called whenever an error is generated. ctx->ErrorValue contains
* the error value.
*/
void (*NearFar)( GLcontext *ctx, GLfloat nearVal, GLfloat farVal );
/*
* Called from glFrustum and glOrtho to tell device driver the
* near and far clipping plane Z values. The 3Dfx driver, for example,
* uses this.
*/
/***
*** For supporting hardware Z buffers:
***/
void (*AllocDepthBuffer)( GLcontext *ctx );
/*
* Called when the depth buffer must be allocated or possibly resized.
*/
void (*ClearDepthBuffer)( GLcontext *ctx );
/*
* Clear the depth buffer to depth specified by CC.Depth.Clear value.
*/
GLuint (*DepthTestSpan)( GLcontext *ctx,
GLuint n, GLint x, GLint y, const GLdepth z[],
GLubyte mask[] );
void (*DepthTestPixels)( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLdepth z[], GLubyte mask[] );
/*
* Apply the depth buffer test to an span/array of pixels and return
* an updated pixel mask. This function is not used when accelerated
* point, line, polygon functions are used.
*/
void (*ReadDepthSpanFloat)( GLcontext *ctx,
GLuint n, GLint x, GLint y, GLfloat depth[]);
void (*ReadDepthSpanInt)( GLcontext *ctx,
GLuint n, GLint x, GLint y, GLdepth depth[] );
/*
* Return depth values as integers for glReadPixels.
* Floats should be returned in the range [0,1].
* Ints (GLdepth) values should be in the range [0,MAXDEPTH].
*/
void (*ClearColorAndDepth)( GLcontext *ctx,
GLboolean all, GLint x, GLint y,
GLint width, GLint height );
/*
* If this function is implemented then it will be called when both the
* color and depth buffers are to be cleared.
*/
/***
*** Accelerated point, line, polygon, glDrawPixels and glBitmap functions:
***/
points_func PointsFunc;
/*
* Called to draw an array of points.
*/
line_func LineFunc;
/*
* Called to draw a line segment.
*/
triangle_func TriangleFunc;
/*
* Called to draw a filled triangle.
*/
quad_func QuadFunc;
/*
* Called to draw a filled quadrilateral.
*/
rect_func RectFunc;
/*
* Called to draw a filled, screen-aligned 2-D rectangle.
*/
GLboolean (*DrawPixels)( GLcontext *ctx,
GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLboolean packed,
const GLvoid *pixels );
/*
* Called from glDrawPixels().
*/
GLboolean (*Bitmap)( GLcontext *ctx, GLsizei width, GLsizei height,
GLfloat xorig, GLfloat yorig,
GLfloat xmove, GLfloat ymove,
const struct gl_image *bitmap );
/*
* Called from glBitmap().
*/
void (*Begin)( GLcontext *ctx, GLenum mode );
void (*End)( GLcontext *ctx );
/*
* These are called whenever glBegin() or glEnd() are called.
* The device driver may do some sort of window locking/unlocking here.
*/
void (*RasterSetup)( GLcontext *ctx, GLuint start, GLuint end );
/*
* This function, if not NULL, is called whenever new window coordinates
* are put in the vertex buffer. The vertices in question are those n
* such that start <= n < end.
* The device driver can convert the window coords to its own specialized
* format. The 3Dfx driver uses this.
*/
GLboolean (*RenderVB)( GLcontext *ctx, GLboolean allDone );
/*
* This function allows the device driver to rasterize an entire
* buffer of primitives at once. See the gl_render_vb() function
* in vbrender.c for more details.
* Return GL_TRUE if vertex buffer successfully rendered.
* Return GL_FALSE if failure, let core Mesa render the vertex buffer.
*/
/***
*** Texture mapping functions:
***/
void (*TexEnv)( GLcontext *ctx, GLenum pname, const GLfloat *param );
/*
* Called whenever glTexEnv*() is called.
* Pname will be one of GL_TEXTURE_ENV_MODE or GL_TEXTURE_ENV_COLOR.
* If pname is GL_TEXTURE_ENV_MODE then param will be one
* of GL_MODULATE, GL_BLEND, GL_DECAL, or GL_REPLACE.
*/
void (*TexImage)( GLcontext *ctx, GLenum target,
struct gl_texture_object *tObj, GLint level,
GLint internalFormat,
const struct gl_texture_image *image );
/*
* Called whenever a texture object's image is changed.
* texObject is the number of the texture object being changed.
* level indicates the mipmap level.
* internalFormat is the format in which the texture is to be stored.
* image is a pointer to a gl_texture_image struct which contains
* the actual image data.
*/
void (*TexSubImage)( GLcontext *ctx, GLenum target,
struct gl_texture_object *tObj, GLint level,
GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height,
GLint internalFormat,
const struct gl_texture_image *image );
/*
* Called from glTexSubImage() to define a sub-region of a texture.
*/
void (*TexParameter)( GLcontext *ctx, GLenum target,
struct gl_texture_object *tObj,
GLenum pname, const GLfloat *params );
/*
* Called whenever glTexParameter*() is called.
* target is GL_TEXTURE_1D or GL_TEXTURE_2D
* texObject is the texture object to modify
* pname is one of GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER,
* GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, or GL_TEXTURE_BORDER_COLOR.
* params is dependant on pname. See man glTexParameter.
*/
void (*BindTexture)( GLcontext *ctx, GLenum target,
struct gl_texture_object *tObj );
/*
* Called whenever glBindTexture() is called. This specifies which
* texture is to be the current one.
*/
void (*DeleteTexture)( GLcontext *ctx, struct gl_texture_object *tObj );
/*
* Called when a texture object can be deallocated.
*/
void (*UpdateTexturePalette)( GLcontext *ctx,
struct gl_texture_object *tObj );
/*
* Called when the texture's color lookup table is changed.
* If tObj is NULL then the shared texture palette ctx->Texture.Palette
* was changed.
*/
};
#endif