diff options
Diffstat (limited to 'nx-X11/extras/Mesa_6.4.2/src/mesa/drivers/svga/svgamesa.c')
| -rw-r--r-- | nx-X11/extras/Mesa_6.4.2/src/mesa/drivers/svga/svgamesa.c | 518 |
1 files changed, 518 insertions, 0 deletions
diff --git a/nx-X11/extras/Mesa_6.4.2/src/mesa/drivers/svga/svgamesa.c b/nx-X11/extras/Mesa_6.4.2/src/mesa/drivers/svga/svgamesa.c new file mode 100644 index 000000000..7e783b540 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.2/src/mesa/drivers/svga/svgamesa.c @@ -0,0 +1,518 @@ +/* $Id: svgamesa.c,v 1.25 2004/11/29 17:30:21 brianp Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 5.0 + * Copyright (C) 1995-2002 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. + */ + + +/* + * SVGA driver for Mesa. + * Original author: Brian Paul + * Additional authors: Slawomir Szczyrba <steev@hot.pl> (Mesa 3.2) + */ + + +#ifdef HAVE_CONFIG_H +#include "conf.h" +#endif + +#ifdef SVGA + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <vga.h> +#include "GL/svgamesa.h" +#include "buffers.h" +#include "context.h" +#include "extensions.h" +#include "imports.h" +#include "matrix.h" +#include "mtypes.h" +#include "swrast/swrast.h" +#include "svgapix.h" +#include "svgamesa8.h" +#include "svgamesa15.h" +#include "svgamesa16.h" +#include "svgamesa24.h" +#include "svgamesa32.h" + +struct svga_buffer SVGABuffer; +vga_modeinfo * SVGAInfo; +SVGAMesaContext SVGAMesa; /* the current context */ + +#ifdef SVGA_DEBUG + +#include <sys/types.h> +#include <signal.h> + +FILE * logfile; +char cbuf[1024]={0}; + +void SVGAlog(char * what) +{ + logfile=fopen("svgamesa.log","a"); + if (!logfile) return; + fprintf(logfile,"%s\n",what); + fclose(logfile); +} +#endif + +/**********************************************************************/ +/***** Init stuff... *****/ +/**********************************************************************/ + +int SVGAMesaInit( int GraphMode ) +{ + vga_init(); + if (!vga_hasmode(GraphMode)) + { + fprintf(stderr,"GraphMode %d unavailable...",GraphMode); +#ifdef SVGA_DEBUG + SVGAlog("SVGAMesaInit: invalid GraphMode (doesn't exist)"); +#endif + return(1); + } + SVGAInfo=vga_getmodeinfo(GraphMode); + if (SVGAInfo->flags & IS_MODEX) + { + fprintf(stderr,"ModeX not implemented..."); +#ifdef SVGA_DEBUG + SVGAlog("SVGAMesaInit: invalid GraphMode (ModeX)"); +#endif + return(2); + } + if (!SVGAInfo->bytesperpixel) + { + fprintf(stderr,"1 / 4 bit color not implemented..."); +#ifdef SVGA_DEBUG + SVGAlog("SVGAMesaInit: invalid GraphMode (1 or 4 bit)"); +#endif + return(3); + } + switch (SVGAInfo->colors) { + case 256: SVGABuffer.Depth = 8; break; + case 32768: SVGABuffer.Depth = 15; break; + case 65536: SVGABuffer.Depth = 16; break; + default: SVGABuffer.Depth = SVGAInfo->bytesperpixel<<3; break; + } + SVGABuffer.BufferSize=SVGAInfo->linewidth*SVGAInfo->height; +#ifdef SVGA_DEBUG + sprintf(cbuf,"SVGAMesaInit: double buffer info.\n" \ + " depth : %d\n" \ + " mode : %d\n" \ + " width : %d\n" \ + " height : %d\n" \ + " bufsize: %d\n", \ + SVGABuffer.Depth,GraphMode,SVGAInfo->linewidth, \ + SVGAInfo->height,SVGABuffer.BufferSize); + SVGAlog(cbuf); +#endif + SVGABuffer.FrontBuffer=(void*)malloc(SVGABuffer.BufferSize + 4); + if (!SVGABuffer.FrontBuffer) { + { + fprintf(stderr,"Not enough RAM for FRONT_LEFT_BUFFER..."); +#ifdef SVGA_DEBUG + SVGAlog("SVGAMesaInit: Not enough RAM (front buffer)"); +#endif + return(4); + } + } +#ifdef SVGA_DEBUG + sprintf(cbuf,"SVGAMesaInit: FrontBuffer - %p",SVGABuffer.FrontBuffer); + SVGAlog(cbuf); +#endif + SVGABuffer.BackBuffer=(void*)malloc(SVGABuffer.BufferSize + 4); + if (!SVGABuffer.BackBuffer) { + { + free(SVGABuffer.FrontBuffer); + fprintf(stderr,"Not enough RAM for BACK_LEFT_BUFFER..."); +#ifdef SVGA_DEBUG + SVGAlog("SVGAMesaInit: Not enough RAM (back buffer)"); +#endif + return(5); + } + } +#ifdef SVGA_DEBUG + sprintf(cbuf,"SVGAMesaInit: BackBuffer - %p",SVGABuffer.BackBuffer); + SVGAlog(cbuf); +#endif + + vga_setmode(GraphMode); + SVGABuffer.VideoRam=vga_getgraphmem(); +#ifdef SVGA_DEBUG + sprintf(cbuf,"SVGAMesaInit: VRAM - %p",SVGABuffer.VideoRam); + SVGAlog(cbuf); + sprintf(cbuf,"SVGAMesaInit: done. (Mode %d)",GraphMode); + SVGAlog(cbuf); +#endif + + SVGABuffer.DrawBuffer = SVGABuffer.BackBuffer; + SVGABuffer.ReadBuffer = SVGABuffer.BackBuffer; + + return 0; +} + +int SVGAMesaClose( void ) +{ + vga_setmode(TEXT); + free(SVGABuffer.FrontBuffer); + free(SVGABuffer.BackBuffer); + return 0; +} + +void SVGAMesaSetCI(int ndx, GLubyte red, GLubyte green, GLubyte blue) +{ + if (ndx<256) + vga_setpalette(ndx, red>>2, green>>2, blue>>2); +} + +/**********************************************************************/ +/***** Miscellaneous functions *****/ +/**********************************************************************/ + +static void copy_buffer( const GLubyte * buffer) { + int size = SVGABuffer.BufferSize, page = 0; + +#ifdef SVGA_DEBUG + sprintf(cbuf,"copy_buffer: copy %p to %p",buffer,SVGABuffer.VideoRam); + SVGAlog(cbuf); +#endif + + while(size>0) { + vga_setpage(page++); + if (size>>16) { + memcpy(SVGABuffer.VideoRam,buffer,0x10000); + buffer+=0x10000; + }else{ + memcpy(SVGABuffer.VideoRam,buffer,size & 0xffff); + } + size-=0xffff; + } +} + +static void get_buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height ) +{ + *width = SVGAMesa->width = vga_getxdim(); + *height = SVGAMesa->height = vga_getydim(); +} + +static void viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h) +{ + /* poll for window size change and realloc software Z/stencil/etc if needed */ + _mesa_ResizeBuffersMESA(); +} + +static void set_buffer( GLcontext *ctx, GLframebuffer *colorBuffer, + GLenum buffer ) +{ + /* We can ignore colorBuffer since we don't support a MakeCurrentRead() + * function. + */ + (void) colorBuffer; + + if (buffer == GL_FRONT_LEFT) { + SVGABuffer.ReadBuffer = SVGABuffer.FrontBuffer; + SVGABuffer.DrawBuffer = SVGABuffer.FrontBuffer; +#if 0 + void * tmpptr; + /* vga_waitretrace(); */ + copy_buffer(SVGABuffer.FrontBuffer); + tmpptr=SVGABuffer.BackBuffer; + SVGABuffer.BackBuffer=SVGABuffer.FrontBuffer; + SVGABuffer.FrontBuffer=tmpptr; +#endif + } + else if (buffer == GL_BACK_LEFT) { + SVGABuffer.ReadBuffer = SVGABuffer.BackBuffer; + SVGABuffer.DrawBuffer = SVGABuffer.BackBuffer; +#if 0 + /* vga_waitretrace(); */ + copy_buffer(SVGABuffer.BackBuffer); +#endif + } +} + +/**********************************************************************/ +/***** *****/ +/**********************************************************************/ + +static void svgamesa_update_state( GLcontext *ctx, GLuint new_state ) +{ + struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx ); + + /* Initialize all the pointers in the DD struct. Do this whenever */ + /* a new context is made current or we change buffers via set_buffer! */ + + ctx->Driver.UpdateState = svgamesa_update_state; + + ctx->Driver.GetBufferSize = get_buffer_size; + ctx->Driver.ResizeBuffers = _swrast_alloc_buffers; + ctx->Driver.Viewport = viewport; + + /* Software rasterizer pixel paths: + */ + ctx->Driver.Accum = _swrast_Accum; + ctx->Driver.Bitmap = _swrast_Bitmap; + ctx->Driver.CopyPixels = _swrast_CopyPixels; + ctx->Driver.DrawPixels = _swrast_DrawPixels; + ctx->Driver.ReadPixels = _swrast_ReadPixels; + ctx->Driver.DrawBuffer = _swrast_DrawBuffer; + + /* Fill in the swrast driver interface: + */ + swdd->SetBuffer = set_buffer; + + switch (SVGABuffer.Depth) { + case 8: ctx->Driver.ClearIndex = __clear_index8; + ctx->Driver.Clear = __clear8; + + swdd->ReadCI32Span = __read_ci32_span8; + swdd->ReadCI32Pixels = __read_ci32_pixels8; + swdd->WriteCI8Span = __write_ci8_span8; + swdd->WriteCI32Span = __write_ci32_span8; + swdd->WriteCI32Pixels = __write_ci32_pixels8; + swdd->WriteMonoCISpan = __write_mono_ci_span8; + swdd->WriteMonoCIPixels = __write_mono_ci_pixels8; +#ifdef SVGA_DEBUG + SVGAlog("SVGAUpdateState: 8 bit mode."); +#endif + + break; + case 15: ctx->Driver.ClearColor = __clear_color15; + ctx->Driver.Clear = __clear15; + + swdd->ReadRGBASpan = __read_rgba_span15; + swdd->ReadRGBAPixels = __read_rgba_pixels15; + swdd->WriteRGBASpan = __write_rgba_span15; + swdd->WriteRGBAPixels = __write_rgba_pixels15; + swdd->WriteMonoRGBASpan = __write_mono_rgba_span15; + swdd->WriteMonoRGBAPixels = __write_mono_rgba_pixels15; +#ifdef SVGA_DEBUG + SVGAlog("SVGAUpdateState: 15 bit mode."); +#endif + break; + case 16: ctx->Driver.ClearColor = __clear_color16; + ctx->Driver.Clear = __clear16; + + swdd->ReadRGBASpan = __read_rgba_span16; + swdd->ReadRGBAPixels = __read_rgba_pixels16; + swdd->WriteRGBASpan = __write_rgba_span16; + swdd->WriteRGBAPixels = __write_rgba_pixels16; + swdd->WriteMonoRGBASpan = __write_mono_rgba_span16; + swdd->WriteMonoRGBAPixels = __write_mono_rgba_pixels16; + break; +#ifdef SVGA_DEBUG + SVGAlog("SVGAUpdateState: 16 bit mode."); +#endif + case 24: ctx->Driver.ClearColor = __clear_color24; + ctx->Driver.Clear = __clear24; + + swdd->ReadRGBASpan = __read_rgba_span24; + swdd->ReadRGBAPixels = __read_rgba_pixels24; + swdd->WriteRGBASpan = __write_rgba_span24; + swdd->WriteRGBAPixels = __write_rgba_pixels24; + swdd->WriteMonoRGBASpan = __write_mono_rgba_span24; + swdd->WriteMonoRGBAPixels = __write_mono_rgba_pixels24; + break; +#ifdef SVGA_DEBUG + SVGAlog("SVGAUpdateState: 32 bit mode."); +#endif + case 32: ctx->Driver.ClearColor = __clear_color32; + ctx->Driver.Clear = __clear32; + + swdd->ReadRGBASpan = __read_rgba_span32; + swdd->ReadRGBAPixels = __read_rgba_pixels32; + swdd->WriteRGBASpan = __write_rgba_span32; + swdd->WriteRGBAPixels = __write_rgba_pixels32; + swdd->WriteMonoRGBASpan = __write_mono_rgba_span32; + swdd->WriteMonoRGBAPixels = __write_mono_rgba_pixels32; + } +} + +/* + * Create a new VGA/Mesa context and return a handle to it. + */ +SVGAMesaContext SVGAMesaCreateContext( GLboolean doubleBuffer ) +{ + SVGAMesaContext ctx; +#ifndef DEV + GLboolean rgb_flag; + GLfloat redscale, greenscale, bluescale, alphascale; + GLint index_bits; + GLint redbits, greenbits, bluebits, alphabits; + + /* determine if we're in RGB or color index mode */ + if ((SVGABuffer.Depth==32) || (SVGABuffer.Depth==24)) { + rgb_flag = GL_TRUE; + redscale = greenscale = bluescale = alphascale = 255.0; + redbits = greenbits = bluebits = 8; + alphabits = 0; + index_bits = 0; + } + else if (SVGABuffer.Depth==8) { + rgb_flag = GL_FALSE; + redscale = greenscale = bluescale = alphascale = 0.0; + redbits = greenbits = bluebits = alphabits = 0; + index_bits = 8; + } + else if (SVGABuffer.Depth==15) { + rgb_flag = GL_TRUE; + redscale = greenscale = bluescale = alphascale = 31.0; + redbits = greenbits = bluebits = 5; + alphabits = 0; + index_bits = 0; + } + else if (SVGABuffer.Depth==16) { + rgb_flag = GL_TRUE; + redscale = bluescale = alphascale = 31.0; + greenscale = 63.0; + redbits = bluebits = 5; + greenbits = 6; + alphabits = 0; + index_bits = 0; + } + + ctx = (SVGAMesaContext) calloc( 1, sizeof(struct svgamesa_context) ); + if (!ctx) { + return NULL; + } + + ctx->gl_vis = _mesa_create_visual( rgb_flag, + doubleBuffer, + GL_FALSE, /* stereo */ + redbits, greenbits, + bluebits, alphabits, + index_bits, + 16, /* depth_size */ + 8, /* stencil_size */ + 16, 16, 16, 16, /* accum_size */ + 1 /* samples */ + ); + + ctx->gl_ctx = _mesa_create_context( ctx->gl_vis, + NULL, /* share list context */ + (void *) ctx, GL_FALSE ); + + _mesa_enable_sw_extensions(ctx->gl_ctx); + _mesa_enable_1_3_extensions(ctx->gl_ctx); + + ctx->gl_buffer = _mesa_create_framebuffer( ctx->gl_vis, + ctx->gl_vis->depthBits > 0, + ctx->gl_vis->stencilBits > 0, + ctx->gl_vis->accumRedBits > 0, + ctx->gl_vis->alphaBits > 0 ); + + ctx->width = ctx->height = 0; /* temporary until first "make-current" */ +#endif + return ctx; +} + +/* + * Destroy the given VGA/Mesa context. + */ +void SVGAMesaDestroyContext( SVGAMesaContext ctx ) +{ +#ifndef DEV + if (ctx) { + _mesa_destroy_visual( ctx->gl_vis ); + _mesa_destroy_context( ctx->gl_ctx ); + _mesa_destroy_framebuffer( ctx->gl_buffer ); + free( ctx ); + if (ctx==SVGAMesa) { + SVGAMesa = NULL; + } + } +#endif +} + +/* + * Make the specified VGA/Mesa context the current one. + */ +void SVGAMesaMakeCurrent( SVGAMesaContext ctx ) +{ +#ifndef DEV + SVGAMesa = ctx; + svgamesa_update_state( ctx->gl_ctx, ~0 ); + _mesa_make_current( ctx->gl_ctx, ctx->gl_buffer ); + + if (ctx->width==0 || ctx->height==0) { + ctx->width = vga_getxdim(); + ctx->height = vga_getydim(); + } +#endif +} + +/* + * Return a handle to the current VGA/Mesa context. + */ +SVGAMesaContext SVGAMesaGetCurrentContext( void ) +{ + return SVGAMesa; +} + +/* + * Swap front/back buffers for current context if double buffered. + */ +void SVGAMesaSwapBuffers( void ) +{ +#if 000 + void * tmpptr; +#endif + + /* vga_waitretrace(); */ + copy_buffer(SVGABuffer.BackBuffer); + +#ifndef DEV + _mesa_notifySwapBuffers( SVGAMesa->gl_ctx ); + if (SVGAMesa->gl_vis->doubleBufferMode) +#endif /* DEV */ + { +#ifdef SVGA_DEBUG + sprintf(cbuf,"SVGAMesaSwapBuffers : Swapping..."); + SVGAlog(cbuf); +#endif /* SVGA_DEBUG */ +#if 000 + tmpptr=SVGABuffer.BackBuffer; + SVGABuffer.BackBuffer=SVGABuffer.FrontBuffer; + SVGABuffer.FrontBuffer=tmpptr; +#endif +#ifdef SVGA_DEBUG + sprintf(cbuf,"SVGAMesaSwapBuffers : WriteBuffer : %p\n" + " Readbuffer : %p", \ + SVGABuffer.BackBuffer, SVGABuffer.FrontBuffer ); + SVGAlog(cbuf); +#endif /* SVGA_DEBUG */ + } +} + +#else /*SVGA*/ + +/* + * Need this to provide at least one external definition when SVGA is + * not defined on the compiler command line. + */ +extern int gl_svga_dummy_function(void); +int gl_svga_dummy_function(void) +{ + return 0; +} + +#endif /*SVGA*/ + |