Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-17 20:38:05 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/dll/opengl/mesa/copypix.c
Jérôme Gardou 5f2bebf7a5 [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
2019-01-19 14:23:54 +01:00

517 lines
15 KiB
C
Raw Blame History

/* $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] );
}
}
Reference in a new issue View git blame Copy permalink