mirror of
https://github.com/reactos/reactos.git
synced 2025-08-01 19:22:58 +00:00
[OPENGL32][MESA] Downgrade Mesa library to version 2.6
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
Jérôme Gardou
parent
905bcf617f
commit
5f2bebf7a5
448 changed files with 56975 additions and 132249 deletions
517
dll/opengl/mesa/copypix.c
Normal file
517
dll/opengl/mesa/copypix.c
Normal file
|
|
@ -0,0 +1,517 @@
|
|||
/* $Id: copypix.c,v 1.7 1998/02/03 23:45:02 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
* Version: 2.4
|
||||
* Copyright (C) 1995-1996 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: copypix.c,v $
|
||||
* Revision 1.7 1998/02/03 23:45:02 brianp
|
||||
* added casts to prevent warnings with Amiga StormC compiler
|
||||
*
|
||||
* Revision 1.6 1997/07/24 01:24:45 brianp
|
||||
* changed precompiled header symbol from PCH to PC_HEADER
|
||||
*
|
||||
* Revision 1.5 1997/06/20 02:20:04 brianp
|
||||
* replaced Current.IntColor with Current.ByteColor
|
||||
*
|
||||
* Revision 1.4 1997/05/28 03:23:48 brianp
|
||||
* added precompiled header (PCH) support
|
||||
*
|
||||
* Revision 1.3 1996/09/15 14:18:10 brianp
|
||||
* now use GLframebuffer and GLvisual
|
||||
*
|
||||
* Revision 1.2 1996/09/15 01:48:58 brianp
|
||||
* removed #define NULL 0
|
||||
*
|
||||
* Revision 1.1 1996/09/13 01:38:16 brianp
|
||||
* Initial revision
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifdef PC_HEADER
|
||||
#include "all.h"
|
||||
#else
|
||||
#include <string.h>
|
||||
#include "context.h"
|
||||
#include "copypix.h"
|
||||
#include "depth.h"
|
||||
#include "feedback.h"
|
||||
#include "dlist.h"
|
||||
#include "macros.h"
|
||||
#include "pixel.h"
|
||||
#include "span.h"
|
||||
#include "stencil.h"
|
||||
#include "types.h"
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
static void copy_rgb_pixels( GLcontext* ctx,
|
||||
GLint srcx, GLint srcy, GLint width, GLint height,
|
||||
GLint destx, GLint desty )
|
||||
{
|
||||
DEFARRAY( GLdepth, zspan, MAX_WIDTH );
|
||||
DEFARRAY( GLubyte, red, MAX_WIDTH );
|
||||
DEFARRAY( GLubyte, green, MAX_WIDTH );
|
||||
DEFARRAY( GLubyte, blue, MAX_WIDTH );
|
||||
DEFARRAY( GLubyte, alpha, MAX_WIDTH );
|
||||
GLboolean scale_or_bias, quick_draw, zoom;
|
||||
GLint sy, dy, stepy;
|
||||
GLint i, j;
|
||||
GLboolean setbuffer;
|
||||
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
zoom = GL_FALSE;
|
||||
}
|
||||
else {
|
||||
zoom = GL_TRUE;
|
||||
}
|
||||
|
||||
/* Determine if copy should be done bottom-to-top or top-to-bottom */
|
||||
if (srcy<desty) {
|
||||
/* top-down max-to-min */
|
||||
sy = srcy + height - 1;
|
||||
dy = desty + height - 1;
|
||||
stepy = -1;
|
||||
}
|
||||
else {
|
||||
/* bottom-up min-to-max */
|
||||
sy = srcy;
|
||||
dy = desty;
|
||||
stepy = 1;
|
||||
}
|
||||
|
||||
scale_or_bias = ctx->Pixel.RedScale!=1.0 || ctx->Pixel.RedBias!=0.0
|
||||
|| ctx->Pixel.GreenScale!=1.0 || ctx->Pixel.GreenBias!=0.0
|
||||
|| ctx->Pixel.BlueScale!=1.0 || ctx->Pixel.BlueBias!=0.0
|
||||
|| ctx->Pixel.AlphaScale!=1.0 || ctx->Pixel.AlphaBias!=0.0;
|
||||
|
||||
if (ctx->Depth.Test) {
|
||||
/* fill in array of z values */
|
||||
GLint z = (GLint) (ctx->Current.RasterPos[2] * DEPTH_SCALE);
|
||||
for (i=0;i<width;i++) {
|
||||
zspan[i] = z;
|
||||
}
|
||||
}
|
||||
|
||||
if (ctx->RasterMask==0 && !zoom
|
||||
&& destx>=0 && destx+width<=ctx->Buffer->Width) {
|
||||
quick_draw = GL_TRUE;
|
||||
}
|
||||
else {
|
||||
quick_draw = GL_FALSE;
|
||||
}
|
||||
|
||||
/* If read and draw buffer are different we must do buffer switching */
|
||||
setbuffer = ctx->Pixel.ReadBuffer!=ctx->Color.DrawBuffer;
|
||||
|
||||
for (j=0; j<height; j++, sy+=stepy, dy+=stepy) {
|
||||
/* read */
|
||||
|
||||
if (setbuffer) {
|
||||
(*ctx->Driver.SetBuffer)( ctx, ctx->Pixel.ReadBuffer );
|
||||
}
|
||||
gl_read_color_span( ctx, width, srcx, sy, red, green, blue, alpha );
|
||||
|
||||
if (scale_or_bias) {
|
||||
GLfloat rbias = ctx->Pixel.RedBias * ctx->Visual->RedScale;
|
||||
GLfloat gbias = ctx->Pixel.GreenBias * ctx->Visual->GreenScale;
|
||||
GLfloat bbias = ctx->Pixel.BlueBias * ctx->Visual->BlueScale;
|
||||
GLfloat abias = ctx->Pixel.AlphaBias * ctx->Visual->AlphaScale;
|
||||
GLint rmax = (GLint) ctx->Visual->RedScale;
|
||||
GLint gmax = (GLint) ctx->Visual->GreenScale;
|
||||
GLint bmax = (GLint) ctx->Visual->BlueScale;
|
||||
GLint amax = (GLint) ctx->Visual->AlphaScale;
|
||||
for (i=0;i<width;i++) {
|
||||
GLint r = red[i] * ctx->Pixel.RedScale + rbias;
|
||||
GLint g = green[i] * ctx->Pixel.GreenScale + gbias;
|
||||
GLint b = blue[i] * ctx->Pixel.BlueScale + bbias;
|
||||
GLint a = alpha[i] * ctx->Pixel.AlphaScale + abias;
|
||||
red[i] = CLAMP( r, 0, rmax );
|
||||
green[i] = CLAMP( g, 0, gmax );
|
||||
blue[i] = CLAMP( b, 0, bmax );
|
||||
alpha[i] = CLAMP( a, 0, amax );
|
||||
}
|
||||
}
|
||||
|
||||
if (ctx->Pixel.MapColorFlag) {
|
||||
GLfloat r = (ctx->Pixel.MapRtoRsize-1) * ctx->Visual->InvRedScale;
|
||||
GLfloat g = (ctx->Pixel.MapGtoGsize-1) * ctx->Visual->InvGreenScale;
|
||||
GLfloat b = (ctx->Pixel.MapBtoBsize-1) * ctx->Visual->InvBlueScale;
|
||||
GLfloat a = (ctx->Pixel.MapAtoAsize-1) * ctx->Visual->InvAlphaScale;
|
||||
for (i=0;i<width;i++) {
|
||||
GLint ir = red[i] * r;
|
||||
GLint ig = green[i] * g;
|
||||
GLint ib = blue[i] * b;
|
||||
GLint ia = alpha[i] * a;
|
||||
red[i] = (GLint) (ctx->Pixel.MapRtoR[ir]*ctx->Visual->RedScale);
|
||||
green[i] = (GLint) (ctx->Pixel.MapGtoG[ig]*ctx->Visual->GreenScale);
|
||||
blue[i] = (GLint) (ctx->Pixel.MapBtoB[ib]*ctx->Visual->BlueScale);
|
||||
alpha[i] = (GLint) (ctx->Pixel.MapAtoA[ia]*ctx->Visual->AlphaScale);
|
||||
}
|
||||
}
|
||||
|
||||
/* write */
|
||||
if (setbuffer) {
|
||||
(*ctx->Driver.SetBuffer)( ctx, ctx->Color.DrawBuffer );
|
||||
}
|
||||
if (quick_draw && dy>=0 && dy<ctx->Buffer->Height) {
|
||||
(*ctx->Driver.WriteColorSpan)( ctx, width, destx, dy,
|
||||
red, green, blue, alpha, NULL);
|
||||
}
|
||||
else if (zoom) {
|
||||
gl_write_zoomed_color_span( ctx, width, destx, dy, zspan,
|
||||
red, green, blue, alpha, desty );
|
||||
}
|
||||
else {
|
||||
gl_write_color_span( ctx, width, destx, dy, zspan,
|
||||
red, green, blue, alpha, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
UNDEFARRAY( zspan );
|
||||
UNDEFARRAY( red );
|
||||
UNDEFARRAY( green );
|
||||
UNDEFARRAY( blue );
|
||||
UNDEFARRAY( alpha );
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void copy_ci_pixels( GLcontext* ctx,
|
||||
GLint srcx, GLint srcy, GLint width, GLint height,
|
||||
GLint destx, GLint desty )
|
||||
{
|
||||
GLdepth zspan[MAX_WIDTH];
|
||||
GLuint indx[MAX_WIDTH];
|
||||
GLint sy, dy, stepy;
|
||||
GLint i, j;
|
||||
GLboolean setbuffer, zoom;
|
||||
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
zoom = GL_FALSE;
|
||||
}
|
||||
else {
|
||||
zoom = GL_TRUE;
|
||||
}
|
||||
|
||||
/* Determine if copy should be bottom-to-top or top-to-bottom */
|
||||
if (srcy<desty) {
|
||||
/* top-down max-to-min */
|
||||
sy = srcy + height - 1;
|
||||
dy = desty + height - 1;
|
||||
stepy = -1;
|
||||
}
|
||||
else {
|
||||
/* bottom-up min-to-max */
|
||||
sy = srcy;
|
||||
dy = desty;
|
||||
stepy = 1;
|
||||
}
|
||||
|
||||
if (ctx->Depth.Test) {
|
||||
/* fill in array of z values */
|
||||
GLint z = (GLint) (ctx->Current.RasterPos[2] * DEPTH_SCALE);
|
||||
for (i=0;i<width;i++) {
|
||||
zspan[i] = z;
|
||||
}
|
||||
}
|
||||
|
||||
/* If read and draw buffer are different we must do buffer switching */
|
||||
setbuffer = ctx->Pixel.ReadBuffer!=ctx->Color.DrawBuffer;
|
||||
|
||||
for (j=0; j<height; j++, sy+=stepy, dy+=stepy) {
|
||||
/* read */
|
||||
if (setbuffer) {
|
||||
(*ctx->Driver.SetBuffer)( ctx, ctx->Pixel.ReadBuffer );
|
||||
}
|
||||
gl_read_index_span( ctx, width, srcx, sy, indx );
|
||||
|
||||
/* shift, offset */
|
||||
if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
|
||||
if (ctx->Pixel.IndexShift<0) {
|
||||
for (i=0;i<width;i++) {
|
||||
indx[i] = (indx[i] >> -ctx->Pixel.IndexShift)
|
||||
+ ctx->Pixel.IndexOffset;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i=0;i<width;i++) {
|
||||
indx[i] = (indx[i] << ctx->Pixel.IndexShift)
|
||||
+ ctx->Pixel.IndexOffset;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* mapping */
|
||||
if (ctx->Pixel.MapColorFlag) {
|
||||
for (i=0;i<width;i++) {
|
||||
if (indx[i] < ctx->Pixel.MapItoIsize) {
|
||||
indx[i] = ctx->Pixel.MapItoI[ indx[i] ];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* write */
|
||||
if (setbuffer) {
|
||||
(*ctx->Driver.SetBuffer)( ctx, ctx->Color.DrawBuffer );
|
||||
}
|
||||
if (zoom) {
|
||||
gl_write_zoomed_index_span( ctx, width, destx, dy, zspan, indx, desty );
|
||||
}
|
||||
else {
|
||||
gl_write_index_span( ctx, width, destx, dy, zspan, indx, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* TODO: Optimize!!!!
|
||||
*/
|
||||
static void copy_depth_pixels( GLcontext* ctx, GLint srcx, GLint srcy,
|
||||
GLint width, GLint height,
|
||||
GLint destx, GLint desty )
|
||||
{
|
||||
GLfloat depth[MAX_WIDTH];
|
||||
GLdepth zspan[MAX_WIDTH];
|
||||
GLuint indx[MAX_WIDTH];
|
||||
GLubyte red[MAX_WIDTH], green[MAX_WIDTH];
|
||||
GLubyte blue[MAX_WIDTH], alpha[MAX_WIDTH];
|
||||
GLint sy, dy, stepy;
|
||||
GLint i, j;
|
||||
GLboolean zoom;
|
||||
|
||||
if (!ctx->Buffer->Depth) {
|
||||
gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
zoom = GL_FALSE;
|
||||
}
|
||||
else {
|
||||
zoom = GL_TRUE;
|
||||
}
|
||||
|
||||
/* Determine if copy should be bottom-to-top or top-to-bottom */
|
||||
if (srcy<desty) {
|
||||
/* top-down max-to-min */
|
||||
sy = srcy + height - 1;
|
||||
dy = desty + height - 1;
|
||||
stepy = -1;
|
||||
}
|
||||
else {
|
||||
/* bottom-up min-to-max */
|
||||
sy = srcy;
|
||||
dy = desty;
|
||||
stepy = 1;
|
||||
}
|
||||
|
||||
/* setup colors or indexes */
|
||||
if (ctx->Visual->RGBAflag) {
|
||||
GLubyte r, g, b, a;
|
||||
r = ctx->Current.ByteColor[0];
|
||||
g = ctx->Current.ByteColor[1];
|
||||
b = ctx->Current.ByteColor[2];
|
||||
a = ctx->Current.ByteColor[3];
|
||||
MEMSET( red, (int) r, width );
|
||||
MEMSET( green, (int) g, width );
|
||||
MEMSET( blue, (int) b, width );
|
||||
MEMSET( alpha, (int) a, width );
|
||||
}
|
||||
else {
|
||||
for (i=0;i<width;i++) {
|
||||
indx[i] = ctx->Current.Index;
|
||||
}
|
||||
}
|
||||
|
||||
for (j=0; j<height; j++, sy+=stepy, dy+=stepy) {
|
||||
/* read */
|
||||
(*ctx->Driver.ReadDepthSpanFloat)( ctx, width, srcx, sy, depth );
|
||||
/* scale, bias, clamp */
|
||||
for (i=0;i<width;i++) {
|
||||
GLfloat d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
|
||||
zspan[i] = (GLint) (CLAMP( d, 0.0, 1.0 ) * DEPTH_SCALE);
|
||||
}
|
||||
/* write */
|
||||
if (ctx->Visual->RGBAflag) {
|
||||
if (zoom) {
|
||||
gl_write_zoomed_color_span( ctx, width, destx, dy, zspan,
|
||||
red, green, blue, alpha, desty );
|
||||
}
|
||||
else {
|
||||
gl_write_color_span( ctx, width, destx, dy, zspan,
|
||||
red, green, blue, alpha, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (zoom) {
|
||||
gl_write_zoomed_index_span( ctx, width, destx, dy,
|
||||
zspan, indx, desty);
|
||||
}
|
||||
else {
|
||||
gl_write_index_span( ctx, width, destx, dy,
|
||||
zspan, indx, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void copy_stencil_pixels( GLcontext* ctx, GLint srcx, GLint srcy,
|
||||
GLint width, GLint height,
|
||||
GLint destx, GLint desty )
|
||||
{
|
||||
GLubyte stencil[MAX_WIDTH];
|
||||
GLint sy, dy, stepy;
|
||||
GLint i, j;
|
||||
GLboolean zoom;
|
||||
|
||||
if (!ctx->Buffer->Stencil) {
|
||||
gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
zoom = GL_FALSE;
|
||||
}
|
||||
else {
|
||||
zoom = GL_TRUE;
|
||||
}
|
||||
|
||||
/* Determine if copy should be bottom-to-top or top-to-bottom */
|
||||
if (srcy<desty) {
|
||||
/* top-down max-to-min */
|
||||
sy = srcy + height - 1;
|
||||
dy = desty + height - 1;
|
||||
stepy = -1;
|
||||
}
|
||||
else {
|
||||
/* bottom-up min-to-max */
|
||||
sy = srcy;
|
||||
dy = desty;
|
||||
stepy = 1;
|
||||
}
|
||||
|
||||
for (j=0; j<height; j++, sy+=stepy, dy+=stepy) {
|
||||
/* read */
|
||||
gl_read_stencil_span( ctx, width, srcx, sy, stencil );
|
||||
/* shift, offset */
|
||||
if (ctx->Pixel.IndexShift<0) {
|
||||
for (i=0;i<width;i++) {
|
||||
stencil[i] = (stencil[i] >> -ctx->Pixel.IndexShift)
|
||||
+ ctx->Pixel.IndexOffset;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i=0;i<width;i++) {
|
||||
stencil[i] = (stencil[i] << ctx->Pixel.IndexShift)
|
||||
+ ctx->Pixel.IndexOffset;
|
||||
}
|
||||
}
|
||||
/* mapping */
|
||||
if (ctx->Pixel.MapStencilFlag) {
|
||||
for (i=0;i<width;i++) {
|
||||
if ((GLint) stencil[i] < ctx->Pixel.MapStoSsize) {
|
||||
stencil[i] = ctx->Pixel.MapStoS[ stencil[i] ];
|
||||
}
|
||||
}
|
||||
}
|
||||
/* write */
|
||||
if (zoom) {
|
||||
gl_write_zoomed_stencil_span( ctx, width, destx, dy, stencil, desty );
|
||||
}
|
||||
else {
|
||||
gl_write_stencil_span( ctx, width, destx, dy, stencil );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void gl_CopyPixels( GLcontext* ctx, GLint srcx, GLint srcy, GLsizei width, GLsizei height,
|
||||
GLenum type )
|
||||
{
|
||||
GLint destx, desty;
|
||||
|
||||
if (INSIDE_BEGIN_END(ctx)) {
|
||||
gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
|
||||
return;
|
||||
}
|
||||
|
||||
if (width<0 || height<0) {
|
||||
gl_error( ctx, GL_INVALID_VALUE, "glCopyPixels" );
|
||||
return;
|
||||
}
|
||||
|
||||
if (ctx->NewState) {
|
||||
gl_update_state(ctx);
|
||||
}
|
||||
|
||||
if (ctx->RenderMode==GL_RENDER) {
|
||||
/* Destination of copy: */
|
||||
if (!ctx->Current.RasterPosValid) {
|
||||
return;
|
||||
}
|
||||
destx = (GLint) (ctx->Current.RasterPos[0] + 0.5F);
|
||||
desty = (GLint) (ctx->Current.RasterPos[1] + 0.5F);
|
||||
|
||||
if (type==GL_COLOR && ctx->Visual->RGBAflag) {
|
||||
copy_rgb_pixels( ctx, srcx, srcy, width, height, destx, desty );
|
||||
}
|
||||
else if (type==GL_COLOR && !ctx->Visual->RGBAflag) {
|
||||
copy_ci_pixels( ctx, srcx, srcy, width, height, destx, desty );
|
||||
}
|
||||
else if (type==GL_DEPTH) {
|
||||
copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
|
||||
}
|
||||
else if (type==GL_STENCIL) {
|
||||
copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
|
||||
}
|
||||
else {
|
||||
gl_error( ctx, GL_INVALID_ENUM, "glCopyPixels" );
|
||||
}
|
||||
}
|
||||
else if (ctx->RenderMode==GL_FEEDBACK) {
|
||||
GLfloat color[4];
|
||||
color[0] = ctx->Current.ByteColor[0] * ctx->Visual->InvRedScale;
|
||||
color[1] = ctx->Current.ByteColor[1] * ctx->Visual->InvGreenScale;
|
||||
color[2] = ctx->Current.ByteColor[2] * ctx->Visual->InvBlueScale;
|
||||
color[3] = ctx->Current.ByteColor[3] * ctx->Visual->InvAlphaScale;
|
||||
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
|
||||
gl_feedback_vertex( ctx, ctx->Current.RasterPos[0],
|
||||
ctx->Current.RasterPos[1],
|
||||
ctx->Current.RasterPos[2],
|
||||
ctx->Current.RasterPos[3],
|
||||
color, ctx->Current.Index,
|
||||
ctx->Current.TexCoord );
|
||||
}
|
||||
else if (ctx->RenderMode==GL_SELECT) {
|
||||
gl_update_hitflag( ctx, ctx->Current.RasterPos[2] );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue