i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make mesa_software_renderer work with latest mesa

Browse Source 
* Some of these changes may be pulled back with the NEW_MESA
  define so this works across older and newer Mesa versions
* NEW_MESA defines and checks should be removed when gcc2 is
  no longer a supported platform
This commit is contained in:
Alexander von Gluck IV
2012-01-08 01:07:57 -06:00
parent f6a611ebf0
commit 41020a0f1a
3 changed files with 180 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/opengl/mesa_software_renderer/Jamfile
+13 -12
View File
@@ -7,12 +7,13 @@ if $(TARGET_PLATFORM) != haiku {
# We need our public GL headers also when not compiling for Haiku. # We need our public GL headers also when not compiling for Haiku.
} }
{ {
local defines ; local defines ;
defines = BEOS_THREADS GNU_ASSEMBLER ; defines = BEOS_THREADS GNU_ASSEMBLER ;
if $(TARGET_ARCH) = x86 { if $(TARGET_ARCH) = x86 {
defines += USE_X86_ASM USE_MMX_ASM USE_3DNOW_ASM USE_SSE_ASM ; defines += USE_X86_ASM USE_MMX_ASM USE_3DNOW_ASM USE_SSE_ASM ;
} else if $(TARGET_ARCH) = ppc { } else if $(TARGET_ARCH) = ppc {
# Not yet supported, as current Mesa3D PPC assembly is Linux-dependent! # Not yet supported, as current Mesa3D PPC assembly is Linux-dependent!
# defines += USE_PPC_ASM ; # defines += USE_PPC_ASM ;
@@ -24,19 +25,19 @@ if $(TARGET_PLATFORM) != haiku {
} }
UsePrivateHeaders interface ; local sources = MesaSoftwareRenderer.cpp ;
UseLibraryHeaders mesa ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa ] ; UsePrivateHeaders interface ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa main ] ; SubDirSysHdrs $(HAIKU_MESA_HEADERS) ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa glapi ] ; Includes [ FGristFiles $(sources) ] : $(HAIKU_MESA_HEADERS_DEPENDENCY) ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa tnl ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa x86 ] ; UseHeaders [ FDirName $(HAIKU_MESA_DIR) include ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa ppc ] ; UseHeaders [ FDirName $(HAIKU_MESA_DIR) src mesa ] ;
UseHeaders [ FDirName $(HAIKU_TOP) src libs mesa mesa sparc ] ; UseHeaders [ FDirName $(HAIKU_MESA_DIR) src mesa main ] ;
UseHeaders [ FDirName $(HAIKU_MESA_DIR) src mapi ] ;
UseHeaders [ FDirName $(HAIKU_MESA_DIR) src mapi glapi ] ;
Addon Mesa\ Software\ Renderer : Addon Mesa\ Software\ Renderer :
MesaSoftwareRenderer.cpp MesaSoftwareRenderer.cpp
: libGL.so libmesa.a be $(TARGET_LIBSUPC++) : libGL.so be $(TARGET_LIBSUPC++)
; ;
src/add-ons/opengl/mesa_software_renderer/MesaSoftwareRenderer.cpp
+142 -121
View File
@@ -1,11 +1,12 @@
/* /*
* Copyright 2006-2008, Haiku. All rights reserved. * Copyright 2006-2011, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
* Jérôme Duval, [email protected] * Jérôme Duval, [email protected]
* Philippe Houdoin, [email protected] * Philippe Houdoin, [email protected]
* Artur Wyszynski, [email protected] * Artur Wyszynski, [email protected]
* Alexander von Gluck, [email protected]
*/ */
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
@@ -23,10 +24,10 @@
#include <GraphicsDefs.h> #include <GraphicsDefs.h>
#include <Screen.h> #include <Screen.h>
extern "C" { extern "C" {
#include "extensions.h" #include "extensions.h"
#include "drivers/common/driverfuncs.h" #include "drivers/common/driverfuncs.h"
#include "drivers/common/meta.h"
#include "main/colormac.h" #include "main/colormac.h"
#include "main/buffers.h" #include "main/buffers.h"
#include "main/framebuffer.h" #include "main/framebuffer.h"
@@ -34,14 +35,16 @@ extern "C" {
#include "main/state.h" #include "main/state.h"
#include "main/version.h" #include "main/version.h"
#include "swrast/swrast.h" #include "swrast/swrast.h"
#ifdef NEW_MESA
#include "swrast/s_renderbuffer.h"
#endif
#include "swrast_setup/swrast_setup.h" #include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h" #include "tnl/tnl.h"
#include "tnl/t_context.h" #include "tnl/t_context.h"
#include "tnl/t_pipeline.h" #include "tnl/t_pipeline.h"
#include "vbo/vbo.h" #include "vbo/vbo.h"
#define CALLED() printf("CALLED %s\n",__PRETTY_FUNCTION__)
#define CALLED() //printf("CALLED %s\n",__PRETTY_FUNCTION__)
#if defined(USE_X86_ASM) #if defined(USE_X86_ASM)
#include "x86/common_x86_asm.h" #include "x86/common_x86_asm.h"
@@ -199,6 +202,7 @@ extern "C" {
} }
extern "C" _EXPORT BGLRenderer* extern "C" _EXPORT BGLRenderer*
instantiate_gl_renderer(BGLView* view, ulong options, instantiate_gl_renderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher) BGLDispatcher* dispatcher)
@@ -208,7 +212,7 @@ instantiate_gl_renderer(BGLView* view, ulong options,
MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options, MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher) BGLDispatcher* dispatcher)
: BGLRenderer(view, options, dispatcher), : BGLRenderer(view, options, dispatcher),
fBitmap(NULL), fBitmap(NULL),
fDirectModeEnabled(false), fDirectModeEnabled(false),
@@ -233,7 +237,7 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
fColorSpace = BScreen(GLView()->Window()).ColorSpace(); fColorSpace = BScreen(GLView()->Window()).ColorSpace();
// We force single buffering for the time being // We force single buffering for the time being
//options &= !BGL_DOUBLE; options &= !BGL_DOUBLE;
const GLboolean rgbFlag = ((options & BGL_INDEX) == 0); const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA); const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
@@ -242,7 +246,6 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
const GLint depth = (options & BGL_DEPTH) ? 16 : 0; const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
const GLint stencil = (options & BGL_STENCIL) ? 8 : 0; const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
const GLint accum = (options & BGL_ACCUM) ? 16 : 0; const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
const GLint index = (options & BGL_INDEX) ? 32 : 0;
const GLint red = rgbFlag ? 8 : 0; const GLint red = rgbFlag ? 8 : 0;
const GLint green = rgbFlag ? 8 : 0; const GLint green = rgbFlag ? 8 : 0;
const GLint blue = rgbFlag ? 8 : 0; const GLint blue = rgbFlag ? 8 : 0;
@@ -251,8 +254,8 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
fOptions = options; // | BGL_INDIRECT; fOptions = options; // | BGL_INDIRECT;
struct dd_function_table functions; struct dd_function_table functions;
fVisual = _mesa_create_visual(rgbFlag, dblFlag, stereoFlag, red, green, fVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green,
blue, alpha, index, depth, stencil, accum, accum, accum, blue, alpha, depth, stencil, accum, accum, accum,
alpha ? accum : 0, 1); alpha ? accum : 0, 1);
// Initialize device driver function table // Initialize device driver function table
@@ -266,7 +269,9 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
functions.Flush = _Flush; functions.Flush = _Flush;
// create core context // create core context
fContext = _mesa_create_context(fVisual, NULL, &functions, this); fContext = _mesa_create_context(API_OPENGL, fVisual, NULL,
&functions, this);
if (!fContext) { if (!fContext) {
_mesa_destroy_visual(fVisual); _mesa_destroy_visual(fVisual);
return; return;
@@ -282,6 +287,7 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
// Use default TCL pipeline // Use default TCL pipeline
TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline; TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline;
_mesa_meta_init(fContext);
_mesa_enable_sw_extensions(fContext); _mesa_enable_sw_extensions(fContext);
_mesa_enable_1_3_extensions(fContext); _mesa_enable_1_3_extensions(fContext);
_mesa_enable_1_4_extensions(fContext); _mesa_enable_1_4_extensions(fContext);
@@ -290,48 +296,73 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
_mesa_enable_2_1_extensions(fContext); _mesa_enable_2_1_extensions(fContext);
// create core framebuffer // create core framebuffer
fFrameBuffer = (struct msr_framebuffer*)_mesa_calloc( fFrameBuffer = (struct msr_framebuffer*)calloc(1,
sizeof(*fFrameBuffer)); sizeof(*fFrameBuffer));
_mesa_initialize_framebuffer(&fFrameBuffer->Base, fVisual); _mesa_initialize_window_framebuffer(&fFrameBuffer->base, fVisual);
fFrontRenderBuffer = (struct msr_renderbuffer*)_mesa_calloc( fFrontRenderBuffer = (struct msr_renderbuffer*)calloc(1,
sizeof(*fFrontRenderBuffer)); sizeof(*fFrontRenderBuffer));
_mesa_init_renderbuffer(&fFrontRenderBuffer->Base, 0); _mesa_init_renderbuffer(&fFrontRenderBuffer->base, 0);
fFrontRenderBuffer->Base.AllocStorage = _FrontRenderbufferStorage; fFrontRenderBuffer->active = true;
fFrontRenderBuffer->Base.Data = NULL; fFrontRenderBuffer->base.InternalFormat = GL_RGBA;
fFrontRenderBuffer->Base.InternalFormat = GL_RGBA; fFrontRenderBuffer->base._BaseFormat = GL_RGBA;
fFrontRenderBuffer->Base._BaseFormat = GL_RGBA; fFrontRenderBuffer->base.DataType = GL_UNSIGNED_BYTE;
fFrontRenderBuffer->Base.DataType = GL_UNSIGNED_BYTE;
fFrontRenderBuffer->Base.RedBits = 8 * sizeof(GLubyte);
fFrontRenderBuffer->Base.GreenBits = 8 * sizeof(GLubyte);
fFrontRenderBuffer->Base.BlueBits = 8 * sizeof(GLubyte);
fFrontRenderBuffer->Base.AlphaBits = 8 * sizeof(GLubyte);
_SetSpanFuncs(fFrontRenderBuffer, fColorSpace);
_mesa_add_renderbuffer(&fFrameBuffer->Base, BUFFER_FRONT_LEFT,
&fFrontRenderBuffer->Base);
if (dblFlag) { switch(fColorSpace) {
fBackRenderBuffer = (struct msr_renderbuffer*)_mesa_calloc( case B_RGB32:
sizeof(*fBackRenderBuffer)); fFrontRenderBuffer->base.Format = MESA_FORMAT_XRGB8888;
_mesa_init_renderbuffer(&fBackRenderBuffer->Base, 0); break;
case B_RGBA32:
fBackRenderBuffer->Base.AllocStorage = _BackRenderbufferStorage; fFrontRenderBuffer->base.Format = MESA_FORMAT_ARGB8888;
fBackRenderBuffer->Base.Data = NULL; break;
fBackRenderBuffer->Base.Delete = _DeleteBackBuffer; case B_RGB24:
fBackRenderBuffer->Base.InternalFormat = GL_RGBA; fFrontRenderBuffer->base.Format = MESA_FORMAT_ARGB8888;
fBackRenderBuffer->Base._BaseFormat = GL_RGBA; break;
fBackRenderBuffer->Base.DataType = GL_UNSIGNED_BYTE; case B_RGB16:
fBackRenderBuffer->Base.RedBits = 8 * sizeof(GLubyte); fFrontRenderBuffer->base.Format = MESA_FORMAT_RGB565;
fBackRenderBuffer->Base.GreenBits = 8 * sizeof(GLubyte); break;
fBackRenderBuffer->Base.BlueBits = 8 * sizeof(GLubyte); case B_RGB15:
fBackRenderBuffer->Base.AlphaBits = 8 * sizeof(GLubyte); case B_RGBA15:
_SetSpanFuncs(fBackRenderBuffer, fColorSpace); fFrontRenderBuffer->base.Format = MESA_FORMAT_ARGB1555;
_mesa_add_renderbuffer(&fFrameBuffer->Base, BUFFER_BACK_LEFT, break;
&fBackRenderBuffer->Base); case B_CMAP8:
default:
fprintf(stderr, "Unsupported screen color space %d\n", fColorSpace);
debugger("Unsupported OpenGL color space");
break;
} }
_mesa_add_soft_renderbuffers(&fFrameBuffer->Base, GL_FALSE, fFrontRenderBuffer->base.AllocStorage = _FrontRenderbufferStorage;
fFrontRenderBuffer->base.Data = NULL;
_SetSpanFuncs(fFrontRenderBuffer, fColorSpace);
_mesa_add_renderbuffer(&fFrameBuffer->base, BUFFER_FRONT_LEFT,
&fFrontRenderBuffer->base);
fBackRenderBuffer = (struct msr_renderbuffer*)calloc(1,
sizeof(*fBackRenderBuffer));
if (dblFlag) {
_mesa_init_renderbuffer(&fBackRenderBuffer->base, 0);
fBackRenderBuffer->active = true;
fBackRenderBuffer->base.AllocStorage = _BackRenderbufferStorage;
fBackRenderBuffer->base.Data = NULL;
fBackRenderBuffer->base.Delete = _DeleteBackBuffer;
fBackRenderBuffer->base.InternalFormat
= fFrontRenderBuffer->base.InternalFormat;
fBackRenderBuffer->base._BaseFormat
= fFrontRenderBuffer->base._BaseFormat;
fBackRenderBuffer->base.Format = fFrontRenderBuffer->base.Format;
_SetSpanFuncs(fBackRenderBuffer, fColorSpace);
_mesa_add_renderbuffer(&fFrameBuffer->base, BUFFER_BACK_LEFT,
&fBackRenderBuffer->base);
} else {
fBackRenderBuffer->active = false;
}
_swrast_add_soft_renderbuffers(&fFrameBuffer->base, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer, fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE); fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
@@ -349,6 +380,7 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
} }
} }
MesaSoftwareRenderer::~MesaSoftwareRenderer() MesaSoftwareRenderer::~MesaSoftwareRenderer()
{ {
CALLED(); CALLED();
@@ -357,7 +389,7 @@ MesaSoftwareRenderer::~MesaSoftwareRenderer()
_tnl_DestroyContext(fContext); _tnl_DestroyContext(fContext);
_vbo_DestroyContext(fContext); _vbo_DestroyContext(fContext);
_mesa_destroy_visual(fVisual); _mesa_destroy_visual(fVisual);
_mesa_destroy_framebuffer(&fFrameBuffer->Base); _mesa_destroy_framebuffer(&fFrameBuffer->base);
_mesa_destroy_context(fContext); _mesa_destroy_context(fContext);
free(fInfo); free(fInfo);
@@ -372,7 +404,7 @@ MesaSoftwareRenderer::LockGL()
CALLED(); CALLED();
BGLRenderer::LockGL(); BGLRenderer::LockGL();
_mesa_make_current(fContext, &fFrameBuffer->Base, &fFrameBuffer->Base); _mesa_make_current(fContext, &fFrameBuffer->base, &fFrameBuffer->base);
color_space cs = B_RGBA32; color_space cs = B_RGBA32;
@@ -385,16 +417,17 @@ MesaSoftwareRenderer::LockGL()
- fInfo->window_bounds.top + 1; - fInfo->window_bounds.top + 1;
} }
if (fBitmap && cs == fColorSpace && fNewWidth == fWidth
&& fNewHeight == fHeight)
return;
if (cs != fColorSpace) { if (cs != fColorSpace) {
fColorSpace = cs; fColorSpace = cs;
_SetSpanFuncs(fFrontRenderBuffer, fColorSpace); _SetSpanFuncs(fFrontRenderBuffer, fColorSpace);
_SetSpanFuncs(fBackRenderBuffer, fColorSpace); if (fBackRenderBuffer->active)
_SetSpanFuncs(fBackRenderBuffer, fColorSpace);
} }
if (fBitmap && fNewWidth == fWidth
&& fNewHeight == fHeight)
return;
fWidth = fNewWidth; fWidth = fNewWidth;
fHeight = fNewHeight; fHeight = fNewHeight;
@@ -418,7 +451,7 @@ void
MesaSoftwareRenderer::SwapBuffers(bool VSync) MesaSoftwareRenderer::SwapBuffers(bool VSync)
{ {
CALLED(); CALLED();
if (!fBitmap) if (!fBitmap)
return; return;
@@ -582,12 +615,13 @@ MesaSoftwareRenderer::_AllocateBitmap()
+ i * fBitmap->BytesPerRow()); + i * fBitmap->BytesPerRow());
} }
_mesa_resize_framebuffer(fContext, &fFrameBuffer->Base, fWidth, fHeight); _mesa_resize_framebuffer(fContext, &fFrameBuffer->base, fWidth, fHeight);
fFrontRenderBuffer->Base.Data = fBitmap->Bits(); fFrontRenderBuffer->base.Data = fBitmap->Bits();
fFrontRenderBuffer->Size = fBitmap->BitsLength(); fFrontRenderBuffer->size = fBitmap->BitsLength();
fBackRenderBuffer->Size = fBitmap->BitsLength(); if (fBackRenderBuffer->active)
fFrameBuffer->Width = fWidth; fBackRenderBuffer->size = fBitmap->BitsLength();
fFrameBuffer->Height = fHeight; fFrameBuffer->width = fWidth;
fFrameBuffer->height = fHeight;
} }
@@ -595,7 +629,7 @@ MesaSoftwareRenderer::_AllocateBitmap()
void void
MesaSoftwareRenderer::_Error(GLcontext* ctx) MesaSoftwareRenderer::_Error(gl_context* ctx)
{ {
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx; MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
if (mr && mr->GLView()) if (mr && mr->GLView())
@@ -604,17 +638,17 @@ MesaSoftwareRenderer::_Error(GLcontext* ctx)
const GLubyte* const GLubyte*
MesaSoftwareRenderer::_GetString(GLcontext* ctx, GLenum name) MesaSoftwareRenderer::_GetString(gl_context* ctx, GLenum name)
{ {
switch (name) { switch (name) {
case GL_VENDOR:
return (const GLubyte*) "Mesa Project";
case GL_RENDERER: { case GL_RENDERER: {
static char buffer[256] = { '\0' }; static char buffer[256] = { '\0' };
if (!buffer[0]) { if (!buffer[0]) {
// Let's build an renderer string // Let's build an renderer string
// TODO: add SVN revision strncat(buffer, "Software Rasterizer", sizeof(buffer));
strncat(buffer, "Haiku's Mesa " MESA_VERSION_STRING
" Software Renderer", sizeof(buffer));
// Append any CPU-specific information. // Append any CPU-specific information.
#ifdef USE_X86_ASM #ifdef USE_X86_ASM
@@ -661,7 +695,7 @@ MesaSoftwareRenderer::_GetString(GLcontext* ctx, GLenum name)
#endif #endif
} }
return (const GLubyte *) buffer; return (const GLubyte*) buffer;
} }
default: default:
// Let core library handle all other cases // Let core library handle all other cases
@@ -671,22 +705,22 @@ MesaSoftwareRenderer::_GetString(GLcontext* ctx, GLenum name)
void void
MesaSoftwareRenderer::_Viewport(GLcontext* ctx, GLint x, GLint y, GLsizei w, MesaSoftwareRenderer::_Viewport(gl_context* ctx, GLint x, GLint y, GLsizei w,
GLsizei h) GLsizei h)
{ {
CALLED(); CALLED();
GLframebuffer* draw = ctx->WinSysDrawBuffer; gl_framebuffer* draw = ctx->WinSysDrawBuffer;
GLframebuffer* read = ctx->WinSysReadBuffer; gl_framebuffer* read = ctx->WinSysReadBuffer;
struct msr_framebuffer* msr = msr_framebuffer(draw); struct msr_framebuffer* msr = msr_framebuffer(draw);
_mesa_resize_framebuffer(ctx, draw, msr->Width, msr->Height); _mesa_resize_framebuffer(ctx, draw, msr->width, msr->height);
_mesa_resize_framebuffer(ctx, read, msr->Width, msr->Height); _mesa_resize_framebuffer(ctx, read, msr->width, msr->height);
} }
void void
MesaSoftwareRenderer::_UpdateState(GLcontext* ctx, GLuint new_state) MesaSoftwareRenderer::_UpdateState(gl_context* ctx, GLuint new_state)
{ {
if (!ctx) if (!ctx)
return; return;
@@ -700,7 +734,7 @@ MesaSoftwareRenderer::_UpdateState(GLcontext* ctx, GLuint new_state)
void void
MesaSoftwareRenderer::_ClearFront(GLcontext* ctx) MesaSoftwareRenderer::_ClearFront(gl_context* ctx)
{ {
CALLED(); CALLED();
@@ -745,32 +779,34 @@ MesaSoftwareRenderer::_ClearFront(GLcontext* ctx)
GLboolean GLboolean
MesaSoftwareRenderer::_FrontRenderbufferStorage(GLcontext* ctx, MesaSoftwareRenderer::_FrontRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, GLenum internalFormat, struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height) GLuint width, GLuint height)
{ {
render->Data = NULL;
render->Width = width; render->Width = width;
render->Height = height; render->Height = height;
render->RowStride = width;
return GL_TRUE; return GL_TRUE;
} }
GLboolean GLboolean
MesaSoftwareRenderer::_BackRenderbufferStorage(GLcontext* ctx, MesaSoftwareRenderer::_BackRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, GLenum internalFormat, struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height) GLuint width, GLuint height)
{ {
struct msr_renderbuffer* mrb = msr_renderbuffer(render); struct msr_renderbuffer* mrb = msr_renderbuffer(render);
_mesa_free(render->Data); free(render->Data);
_FrontRenderbufferStorage(ctx, render, internalFormat, width, height); _FrontRenderbufferStorage(ctx, render, internalFormat, width, height);
render->Data = _mesa_malloc(mrb->Size); render->Data = malloc(mrb->size);
return GL_TRUE; return GL_TRUE;
} }
void void
MesaSoftwareRenderer::_Flush(GLcontext* ctx) MesaSoftwareRenderer::_Flush(gl_context* ctx)
{ {
CALLED(); CALLED();
MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx; MesaSoftwareRenderer* mr = (MesaSoftwareRenderer*)ctx->DriverCtx;
@@ -787,60 +823,45 @@ void
MesaSoftwareRenderer::_SetSpanFuncs( MesaSoftwareRenderer::_SetSpanFuncs(
struct msr_renderbuffer* buffer, color_space colorSpace) struct msr_renderbuffer* buffer, color_space colorSpace)
{ {
if (!buffer->active)
return;
switch (colorSpace) { switch (colorSpace) {
case B_RGBA32: case B_RGBA32:
buffer->Base.GetRow = get_row_RGBA32; buffer->base.GetRow = get_row_RGBA32;
buffer->Base.GetValues = get_values_RGBA32; buffer->base.GetValues = get_values_RGBA32;
buffer->Base.PutRow = put_row_RGBA32; buffer->base.PutRow = put_row_RGBA32;
buffer->Base.PutRowRGB = put_row_rgb_RGBA32; buffer->base.PutValues = put_values_RGBA32;
buffer->Base.PutMonoRow = put_mono_row_RGBA32;
buffer->Base.PutValues = put_values_RGBA32;
buffer->Base.PutMonoValues = put_mono_values_RGBA32;
break; break;
case B_RGB32: case B_RGB32:
buffer->Base.GetRow = get_row_RGB32; buffer->base.GetRow = get_row_RGB32;
buffer->Base.GetValues = get_values_RGB32; buffer->base.GetValues = get_values_RGB32;
buffer->Base.PutRow = put_row_RGB32; buffer->base.PutRow = put_row_RGB32;
buffer->Base.PutRowRGB = put_row_rgb_RGB32; buffer->base.PutValues = put_values_RGB32;
buffer->Base.PutMonoRow = put_mono_row_RGB32;
buffer->Base.PutValues = put_values_RGB32;
buffer->Base.PutMonoValues = put_mono_values_RGB32;
break; break;
case B_RGB24: case B_RGB24:
buffer->Base.GetRow = get_row_RGB24; buffer->base.GetRow = get_row_RGB24;
buffer->Base.GetValues = get_values_RGB24; buffer->base.GetValues = get_values_RGB24;
buffer->Base.PutRow = put_row_RGB24; buffer->base.PutRow = put_row_RGB24;
buffer->Base.PutRowRGB = put_row_rgb_RGB24; buffer->base.PutValues = put_values_RGB24;
buffer->Base.PutMonoRow = put_mono_row_RGB24;
buffer->Base.PutValues = put_values_RGB24;
buffer->Base.PutMonoValues = put_mono_values_RGB24;
break; break;
case B_RGB16: case B_RGB16:
buffer->Base.GetRow = get_row_RGB16; buffer->base.GetRow = get_row_RGB16;
buffer->Base.GetValues = get_values_RGB16; buffer->base.GetValues = get_values_RGB16;
buffer->Base.PutRow = put_row_RGB16; buffer->base.PutRow = put_row_RGB16;
buffer->Base.PutRowRGB = put_row_rgb_RGB16; buffer->base.PutValues = put_values_RGB16;
buffer->Base.PutMonoRow = put_mono_row_RGB16;
buffer->Base.PutValues = put_values_RGB16;
buffer->Base.PutMonoValues = put_mono_values_RGB16;
break; break;
case B_RGB15: case B_RGB15:
buffer->Base.GetRow = get_row_RGB15; buffer->base.GetRow = get_row_RGB15;
buffer->Base.GetValues = get_values_RGB15; buffer->base.GetValues = get_values_RGB15;
buffer->Base.PutRow = put_row_RGB15; buffer->base.PutRow = put_row_RGB15;
buffer->Base.PutRowRGB = put_row_rgb_RGB15; buffer->base.PutValues = put_values_RGB15;
buffer->Base.PutMonoRow = put_mono_row_RGB15;
buffer->Base.PutValues = put_values_RGB15;
buffer->Base.PutMonoValues = put_mono_values_RGB15;
break; break;
case B_CMAP8: case B_CMAP8:
buffer->Base.GetRow = get_row_CMAP8; buffer->base.GetRow = get_row_CMAP8;
buffer->Base.GetValues = get_values_CMAP8; buffer->base.GetValues = get_values_CMAP8;
buffer->Base.PutRow = put_row_CMAP8; buffer->base.PutRow = put_row_CMAP8;
buffer->Base.PutRowRGB = put_row_rgb_CMAP8; buffer->base.PutValues = put_values_CMAP8;
buffer->Base.PutMonoRow = put_mono_row_CMAP8;
buffer->Base.PutValues = put_values_CMAP8;
buffer->Base.PutMonoValues = put_mono_values_CMAP8;
break; break;
default: default:
fprintf(stderr, "Unsupported screen color space %d\n", fColorSpace); fprintf(stderr, "Unsupported screen color space %d\n", fColorSpace);
@@ -853,8 +874,8 @@ MesaSoftwareRenderer::_SetSpanFuncs(
void void
MesaSoftwareRenderer::_DeleteBackBuffer(struct gl_renderbuffer* rb) MesaSoftwareRenderer::_DeleteBackBuffer(struct gl_renderbuffer* rb)
{ {
_mesa_free(rb->Data); free(rb->Data);
_mesa_free(rb); free(rb);
} }
src/add-ons/opengl/mesa_software_renderer/MesaSoftwareRenderer.h
+25 -15
View File
@@ -21,10 +21,18 @@
extern "C" { extern "C" {
#include "context.h" #include "context.h"
#include "swrast/s_chan.h"
#if defined(__GNUC__) && (__GNUC__ > 2)
#define NEW_MESA
#endif
struct msr_renderbuffer { struct msr_renderbuffer {
struct gl_renderbuffer Base; struct gl_renderbuffer base;
uint32 Size; uint32 size;
bool active;
}; };
@@ -36,9 +44,9 @@ msr_renderbuffer(struct gl_renderbuffer* rb)
struct msr_framebuffer { struct msr_framebuffer {
struct gl_framebuffer Base; struct gl_framebuffer base;
uint32 Width; uint32 width;
uint32 Height; uint32 height;
}; };
@@ -48,8 +56,10 @@ msr_framebuffer(struct gl_framebuffer* rb)
return (struct msr_framebuffer*)rb; return (struct msr_framebuffer*)rb;
} }
} }
class MesaSoftwareRenderer : public BGLRenderer { class MesaSoftwareRenderer : public BGLRenderer {
public: public:
MesaSoftwareRenderer(BGLView* view, MesaSoftwareRenderer(BGLView* view,
@@ -72,21 +82,21 @@ public:
virtual void DirectConnected(direct_buffer_info* info); virtual void DirectConnected(direct_buffer_info* info);
private: private:
static void _Error(GLcontext* ctx); static void _Error(gl_context* ctx);
static const GLubyte* _GetString(GLcontext* ctx, GLenum name); static const GLubyte* _GetString(gl_context* ctx, GLenum name);
static void _Viewport(GLcontext* ctx, GLint x, GLint y, static void _Viewport(gl_context* ctx, GLint x, GLint y,
GLsizei w, GLsizei h); GLsizei w, GLsizei h);
static void _UpdateState(GLcontext* ctx, GLuint newState); static void _UpdateState(gl_context* ctx, GLuint newState);
static void _ClearFront(GLcontext* ctx); static void _ClearFront(gl_context* ctx);
static GLboolean _FrontRenderbufferStorage(GLcontext* ctx, static GLboolean _FrontRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, struct gl_renderbuffer* render,
GLenum internalFormat, GLenum internalFormat,
GLuint width, GLuint height); GLuint width, GLuint height);
static GLboolean _BackRenderbufferStorage(GLcontext* ctx, static GLboolean _BackRenderbufferStorage(gl_context* ctx,
struct gl_renderbuffer* render, struct gl_renderbuffer* render,
GLenum internalFormat, GLenum internalFormat,
GLuint width, GLuint height); GLuint width, GLuint height);
static void _Flush(GLcontext *ctx); static void _Flush(gl_context *ctx);
void _SetSpanFuncs(struct msr_renderbuffer* buffer, void _SetSpanFuncs(struct msr_renderbuffer* buffer,
color_space colorSpace); color_space colorSpace);
static void _DeleteBackBuffer(struct gl_renderbuffer* rb); static void _DeleteBackBuffer(struct gl_renderbuffer* rb);
@@ -100,8 +110,8 @@ private:
BLocker fInfoLocker; BLocker fInfoLocker;
ulong fOptions; ulong fOptions;
GLcontext* fContext; gl_context* fContext;
GLvisual* fVisual; gl_config* fVisual;
struct msr_framebuffer* fFrameBuffer; struct msr_framebuffer* fFrameBuffer;
struct msr_renderbuffer* fFrontRenderBuffer; struct msr_renderbuffer* fFrontRenderBuffer;
struct msr_renderbuffer* fBackRenderBuffer; struct msr_renderbuffer* fBackRenderBuffer;