Aren
/
haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* Added double-buffering 

* Resolved a vsync TODO


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33234 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Artur Wyszynski 2009-09-22 01:02:15 +00:00
parent bd61cb15e6
commit bf2de2050d
2 changed files with 248 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

355
src/add-ons/opengl/mesa_software_renderer/MesaSoftwareRenderer.cpp
View File

@ -5,6 +5,7 @@
* Authors:
* Jérôme Duval, korli@users.berlios.de
* Philippe Houdoin, philippe.houdoin@free.fr
* Artur Wyszynski, harakash@gmail.com
*/
/*
* Mesa 3-D graphics library
@ -13,15 +14,16 @@
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*/
#define CALLED() //printf("CALLED %s\n",__PRETTY_FUNCTION__)
#include "MesaSoftwareRenderer.h"
#include <stdio.h>
#include <string.h>
#include <Autolock.h>
#include <DirectWindowPrivate.h>
#include <GraphicsDefs.h>
#include <Screen.h>
extern "C" {
#include "extensions.h"
#include "drivers/common/driverfuncs.h"
@ -39,6 +41,8 @@ extern "C" {
#include "vbo/vbo.h"
#define CALLED() //printf("CALLED %s\n",__PRETTY_FUNCTION__)
#if defined(USE_X86_ASM)
#include "x86/common_x86_asm.h"
#endif
@ -70,6 +74,8 @@ extern const char * color_space_name(color_space space);
/***** Read/write spans/arrays of pixels *****/
/**********************************************************************/
extern "C" {
/* 32-bit RGBA */
#define NAME(PREFIX) PREFIX##_RGBA32
#define RB_TYPE GLubyte
@ -191,6 +197,8 @@ extern const char * color_space_name(color_space space);
DST[ACOMP] = 0xff
#include "swrast/s_spantemp.h"
}
extern "C" _EXPORT BGLRenderer*
instantiate_gl_renderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
@ -209,6 +217,8 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
fContext(NULL),
fVisual(NULL),
fFrameBuffer(NULL),
fFrontRenderBuffer(NULL),
fBackRenderBuffer(NULL),
fColorSpace(B_NO_COLOR_SPACE)
{
CALLED();
@ -220,12 +230,14 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
fClearIndex = 0;
fColorSpace = BScreen(GLView()->Window()).ColorSpace();
// We force single buffering for the time being
//options &= !BGL_DOUBLE;
const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
const GLboolean dblFlag = false; //((options & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean dblFlag = ((options & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean stereoFlag = false;
const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
@ -246,14 +258,12 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
// Initialize device driver function table
_mesa_init_driver_functions(&functions);
functions.GetString = GetString;
functions.UpdateState = UpdateState;
//functions.Clear = Clear;
//functions.ClearIndex = ClearIndex;
//functions.ClearColor = ClearColor;
functions.Error = Error;
functions.Viewport = Viewport;
functions.Flush = Flush;
functions.GetString = _GetString;
functions.UpdateState = _UpdateState;
functions.GetBufferSize = NULL;
functions.Error = _Error;
functions.Viewport = _Viewport;
functions.Flush = _Flush;
// create core context
fContext = _mesa_create_context(fVisual, NULL, &functions, this);
@ -262,9 +272,6 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
return;
}
// create core framebuffer
fFrameBuffer = _mesa_create_framebuffer(fVisual);
/* Initialize the software rasterizer and helper modules. */
_swrast_CreateContext(fContext);
_vbo_CreateContext(fContext);
@ -272,24 +279,6 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
_swsetup_CreateContext(fContext);
_swsetup_Wakeup(fContext);
fRenderBuffer = _mesa_new_renderbuffer(fContext, BUFFER_FRONT_LEFT);
fRenderBuffer->InternalFormat = GL_RGBA;
fRenderBuffer->_BaseFormat = GL_RGBA;
fRenderBuffer->DataType = GL_UNSIGNED_BYTE;
fRenderBuffer->Data = NULL;
fRenderBuffer->AllocStorage = RenderbufferStorage;
_mesa_add_renderbuffer(fFrameBuffer, BUFFER_FRONT_LEFT, fRenderBuffer);
_mesa_add_soft_renderbuffers(fFrameBuffer,
GL_FALSE,
fVisual->haveDepthBuffer,
fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer,
alphaFlag,
GL_FALSE);
// Use default TCL pipeline
TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline;
@ -300,13 +289,60 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
_mesa_enable_2_0_extensions(fContext);
_mesa_enable_2_1_extensions(fContext);
// create core framebuffer
fFrameBuffer = (struct msr_framebuffer*)_mesa_calloc(
sizeof(*fFrameBuffer));
_mesa_initialize_framebuffer(&fFrameBuffer->Base, fVisual);
fFrontRenderBuffer = (struct msr_renderbuffer*)_mesa_calloc(
sizeof(*fFrontRenderBuffer));
_mesa_init_renderbuffer(&fFrontRenderBuffer->Base, 0);
fFrontRenderBuffer->Base.AllocStorage = _FrontRenderbufferStorage;
fFrontRenderBuffer->Base.Data = NULL;
fFrontRenderBuffer->Base.InternalFormat = GL_RGBA;
fFrontRenderBuffer->Base._BaseFormat = GL_RGBA;
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) {
fBackRenderBuffer = (struct msr_renderbuffer*)_mesa_calloc(
sizeof(*fBackRenderBuffer));
_mesa_init_renderbuffer(&fBackRenderBuffer->Base, 0);
fBackRenderBuffer->Base.AllocStorage = _BackRenderbufferStorage;
fBackRenderBuffer->Base.Data = NULL;
fBackRenderBuffer->Base.Delete = _DeleteBackBuffer;
fBackRenderBuffer->Base.InternalFormat = GL_RGBA;
fBackRenderBuffer->Base._BaseFormat = GL_RGBA;
fBackRenderBuffer->Base.DataType = GL_UNSIGNED_BYTE;
fBackRenderBuffer->Base.RedBits = 8 * sizeof(GLubyte);
fBackRenderBuffer->Base.GreenBits = 8 * sizeof(GLubyte);
fBackRenderBuffer->Base.BlueBits = 8 * sizeof(GLubyte);
fBackRenderBuffer->Base.AlphaBits = 8 * sizeof(GLubyte);
_SetSpanFuncs(fBackRenderBuffer, fColorSpace);
_mesa_add_renderbuffer(&fFrameBuffer->Base, BUFFER_BACK_LEFT,
&fBackRenderBuffer->Base);
}
_mesa_add_soft_renderbuffers(&fFrameBuffer->Base, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
BRect bounds = view->Bounds();
fWidth = fNewWidth = (GLint)bounds.Width();
fHeight = fNewHeight = (GLint)bounds.Height();
// some stupid applications (Quake2) don't even think about calling LockGL()
// before using glGetString and its glGet*() friends...
// so make sure there is at least a valid context.
if (!_mesa_get_current_context()) {
LockGL();
// not needed, we don't have a looper yet: UnlockLooper();
@ -316,12 +352,16 @@ MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
MesaSoftwareRenderer::~MesaSoftwareRenderer()
{
CALLED();
_swsetup_DestroyContext(fContext);
_swrast_DestroyContext(fContext);
_tnl_DestroyContext(fContext);
_vbo_DestroyContext(fContext);
_mesa_destroy_visual(fVisual);
_mesa_destroy_framebuffer(fFrameBuffer);
_mesa_destroy_framebuffer(&fFrameBuffer->Base);
_mesa_destroy_context(fContext);
free(fInfo);
delete fBitmap;
}
@ -332,85 +372,27 @@ MesaSoftwareRenderer::LockGL()
CALLED();
BGLRenderer::LockGL();
_mesa_make_current(fContext, fFrameBuffer, fFrameBuffer);
_mesa_make_current(fContext, &fFrameBuffer->Base, &fFrameBuffer->Base);
color_space cs = B_RGBA32;
BAutolock lock(fInfoLocker);
if (fDirectModeEnabled && fInfo != NULL) {
cs = BScreen(GLView()->Window()).ColorSpace();
fNewWidth = fInfo->window_bounds.right
fNewWidth = fInfo->window_bounds.right
- fInfo->window_bounds.left + 1;
fNewHeight = fInfo->window_bounds.bottom
fNewHeight = fInfo->window_bounds.bottom
- fInfo->window_bounds.top + 1;
}
if (fBitmap && cs == fColorSpace && fNewWidth == fWidth
if (fBitmap && cs == fColorSpace && fNewWidth == fWidth
&& fNewHeight == fHeight)
return;
if (cs != fColorSpace) {
fColorSpace = cs;
switch (fColorSpace) {
case B_RGBA32:
fRenderBuffer->GetRow = get_row_RGBA32;
fRenderBuffer->GetValues = get_values_RGBA32;
fRenderBuffer->PutRow = put_row_RGBA32;
fRenderBuffer->PutRowRGB = put_row_rgb_RGBA32;
fRenderBuffer->PutMonoRow = put_mono_row_RGBA32;
fRenderBuffer->PutValues = put_values_RGBA32;
fRenderBuffer->PutMonoValues = put_mono_values_RGBA32;
break;
case B_RGB32:
fRenderBuffer->GetRow = get_row_RGB32;
fRenderBuffer->GetValues = get_values_RGB32;
fRenderBuffer->PutRow = put_row_RGB32;
fRenderBuffer->PutRowRGB = put_row_rgb_RGB32;
fRenderBuffer->PutMonoRow = put_mono_row_RGB32;
fRenderBuffer->PutValues = put_values_RGB32;
fRenderBuffer->PutMonoValues = put_mono_values_RGB32;
break;
case B_RGB24:
fRenderBuffer->GetRow = get_row_RGB24;
fRenderBuffer->GetValues = get_values_RGB24;
fRenderBuffer->PutRow = put_row_RGB24;
fRenderBuffer->PutRowRGB = put_row_rgb_RGB24;
fRenderBuffer->PutMonoRow = put_mono_row_RGB24;
fRenderBuffer->PutValues = put_values_RGB24;
fRenderBuffer->PutMonoValues = put_mono_values_RGB24;
break;
case B_RGB16:
fRenderBuffer->GetRow = get_row_RGB16;
fRenderBuffer->GetValues = get_values_RGB16;
fRenderBuffer->PutRow = put_row_RGB16;
fRenderBuffer->PutRowRGB = put_row_rgb_RGB16;
fRenderBuffer->PutMonoRow = put_mono_row_RGB16;
fRenderBuffer->PutValues = put_values_RGB16;
fRenderBuffer->PutMonoValues = put_mono_values_RGB16;
break;
case B_RGB15:
fRenderBuffer->GetRow = get_row_RGB15;
fRenderBuffer->GetValues = get_values_RGB15;
fRenderBuffer->PutRow = put_row_RGB15;
fRenderBuffer->PutRowRGB = put_row_rgb_RGB15;
fRenderBuffer->PutMonoRow = put_mono_row_RGB15;
fRenderBuffer->PutValues = put_values_RGB15;
fRenderBuffer->PutMonoValues = put_mono_values_RGB15;
break;
case B_CMAP8:
fRenderBuffer->GetRow = get_row_CMAP8;
fRenderBuffer->GetValues = get_values_CMAP8;
fRenderBuffer->PutRow = put_row_CMAP8;
fRenderBuffer->PutRowRGB = put_row_rgb_CMAP8;
fRenderBuffer->PutMonoRow = put_mono_row_CMAP8;
fRenderBuffer->PutValues = put_values_CMAP8;
fRenderBuffer->PutMonoValues = put_mono_values_CMAP8;
break;
default:
fprintf(stderr, "unsupported screen color space %d\n", fColorSpace);
debugger("unsupported OpenGL color space");
break;
}
_SetSpanFuncs(fFrontRenderBuffer, fColorSpace);
_SetSpanFuncs(fBackRenderBuffer, fColorSpace);
}
fWidth = fNewWidth;
@ -437,10 +419,9 @@ MesaSoftwareRenderer::SwapBuffers(bool VSync)
{
CALLED();
// TODO: support VSync
if (!fBitmap)
return;
if (fVisual->doubleBufferMode)
_mesa_notifySwapBuffers(fContext);
@ -471,7 +452,7 @@ MesaSoftwareRenderer::SwapBuffers(bool VSync)
* fInfo->bytes_per_row + clip->left * bytesPerPixel;
uint8 *b = (uint8 *)fBitmap->Bits()
+ (clip->top - fInfo->window_bounds.top) * bytesPerRow
+ (clip->left - fInfo->window_bounds.left)
+ (clip->left - fInfo->window_bounds.left)
* bytesPerPixel;
for (int y = 0; y < height; y++) {
@ -480,6 +461,11 @@ MesaSoftwareRenderer::SwapBuffers(bool VSync)
b += bytesPerRow;
}
}
if (VSync) {
BScreen screen(GLView()->Window());
screen.WaitForRetrace();
}
}
@ -489,7 +475,7 @@ MesaSoftwareRenderer::Draw(BRect updateRect)
CALLED();
if (fBitmap && (!fDirectModeEnabled || (fInfo == NULL)))
GLView()->DrawBitmap(fBitmap, updateRect, updateRect);
}
@ -578,7 +564,7 @@ MesaSoftwareRenderer::EnableDirectMode(bool enabled)
void
MesaSoftwareRenderer::DirectConnected(direct_buffer_info *info)
{
{
// TODO: I'm not sure we need to do this: BGLView already
// keeps a local copy of the direct_buffer_info passed by
// BDirectWindow::DirectConnected().
@ -594,7 +580,7 @@ MesaSoftwareRenderer::DirectConnected(direct_buffer_info *info)
free(fInfo);
fInfo = NULL;
}
}
@ -622,8 +608,12 @@ MesaSoftwareRenderer::_AllocateBitmap()
+ i * fBitmap->BytesPerRow());
}
_mesa_resize_framebuffer(fContext, fFrameBuffer, fWidth, fHeight);
fRenderBuffer->Data = fBitmap->Bits();
_mesa_resize_framebuffer(fContext, &fFrameBuffer->Base, fWidth, fHeight);
fFrontRenderBuffer->Base.Data = fBitmap->Bits();
fFrontRenderBuffer->Size = fBitmap->BitsLength();
fBackRenderBuffer->Size = fBitmap->BitsLength();
fFrameBuffer->Width = fWidth;
fFrameBuffer->Height = fHeight;
}
@ -631,7 +621,7 @@ MesaSoftwareRenderer::_AllocateBitmap()
void
MesaSoftwareRenderer::Error(GLcontext *ctx)
MesaSoftwareRenderer::_Error(GLcontext *ctx)
{
MesaSoftwareRenderer *mr = (MesaSoftwareRenderer *) ctx->DriverCtx;
if (mr && mr->GLView())
@ -640,7 +630,7 @@ MesaSoftwareRenderer::Error(GLcontext *ctx)
const GLubyte *
MesaSoftwareRenderer::GetString(GLcontext *ctx, GLenum name)
MesaSoftwareRenderer::_GetString(GLcontext *ctx, GLenum name)
{
switch (name) {
case GL_RENDERER: {
@ -707,17 +697,22 @@ MesaSoftwareRenderer::GetString(GLcontext *ctx, GLenum name)
void
MesaSoftwareRenderer::Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w,
MesaSoftwareRenderer::_Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w,
GLsizei h)
{
CALLED();
// poll for window size change and realloc software Z/stencil/etc if needed
_mesa_ResizeBuffersMESA();
GLframebuffer *draw = ctx->WinSysDrawBuffer;
GLframebuffer *read = ctx->WinSysReadBuffer;
struct msr_framebuffer *msr = msr_framebuffer(draw);
_mesa_resize_framebuffer(ctx, draw, msr->Width, msr->Height);
_mesa_resize_framebuffer(ctx, read, msr->Width, msr->Height);
}
void
MesaSoftwareRenderer::UpdateState(GLcontext *ctx, GLuint new_state)
MesaSoftwareRenderer::_UpdateState(GLcontext *ctx, GLuint new_state)
{
if (!ctx)
return;
@ -731,44 +726,7 @@ MesaSoftwareRenderer::UpdateState(GLcontext *ctx, GLuint new_state)
void
MesaSoftwareRenderer::ClearIndex(GLcontext *ctx, GLuint index)
{
CALLED();
MesaSoftwareRenderer *mr = (MesaSoftwareRenderer *) ctx->DriverCtx;
mr->fClearIndex = index;
}
void
MesaSoftwareRenderer::ClearColor(GLcontext *ctx, const GLfloat color[4])
{
CALLED();
MesaSoftwareRenderer *mr = (MesaSoftwareRenderer *) ctx->DriverCtx;
CLAMPED_FLOAT_TO_CHAN(mr->fClearColor[BE_RCOMP], color[0]);
CLAMPED_FLOAT_TO_CHAN(mr->fClearColor[BE_GCOMP], color[1]);
CLAMPED_FLOAT_TO_CHAN(mr->fClearColor[BE_BCOMP], color[2]);
CLAMPED_FLOAT_TO_CHAN(mr->fClearColor[BE_ACOMP], color[3]);
assert(mr->GLView());
}
void
MesaSoftwareRenderer::Clear(GLcontext *ctx, GLbitfield mask)
{
CALLED();
if (mask & BUFFER_BIT_FRONT_LEFT)
ClearFront(ctx);
mask &= ~(BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT);
if (mask)
_swrast_Clear(ctx, mask);
}
void
MesaSoftwareRenderer::ClearFront(GLcontext *ctx)
MesaSoftwareRenderer::_ClearFront(GLcontext *ctx)
{
CALLED();
@ -813,18 +771,32 @@ MesaSoftwareRenderer::ClearFront(GLcontext *ctx)
GLboolean
MesaSoftwareRenderer::RenderbufferStorage(GLcontext* ctx,
MesaSoftwareRenderer::_FrontRenderbufferStorage(GLcontext* ctx,
struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height)
{
render->Width = width;
render->Height = height;
return GL_TRUE;
}
GLboolean
MesaSoftwareRenderer::_BackRenderbufferStorage(GLcontext* ctx,
struct gl_renderbuffer* render, GLenum internalFormat,
GLuint width, GLuint height)
{
struct msr_renderbuffer *mrb = msr_renderbuffer(render);
_mesa_free(render->Data);
_FrontRenderbufferStorage(ctx, render, internalFormat, width, height);
render->Data = _mesa_malloc(mrb->Size);
return GL_TRUE;
}
void
MesaSoftwareRenderer::Flush(GLcontext *ctx)
MesaSoftwareRenderer::_Flush(GLcontext *ctx)
{
CALLED();
MesaSoftwareRenderer *mr = (MesaSoftwareRenderer *) ctx->DriverCtx;
@ -833,3 +805,78 @@ MesaSoftwareRenderer::Flush(GLcontext *ctx)
}
}
void
MesaSoftwareRenderer::_SetSpanFuncs(
struct msr_renderbuffer* buffer, color_space colorSpace)
{
switch (colorSpace) {
case B_RGBA32:
buffer->Base.GetRow = get_row_RGBA32;
buffer->Base.GetValues = get_values_RGBA32;
buffer->Base.PutRow = put_row_RGBA32;
buffer->Base.PutRowRGB = put_row_rgb_RGBA32;
buffer->Base.PutMonoRow = put_mono_row_RGBA32;
buffer->Base.PutValues = put_values_RGBA32;
buffer->Base.PutMonoValues = put_mono_values_RGBA32;
break;
case B_RGB32:
buffer->Base.GetRow = get_row_RGB32;
buffer->Base.GetValues = get_values_RGB32;
buffer->Base.PutRow = put_row_RGB32;
buffer->Base.PutRowRGB = put_row_rgb_RGB32;
buffer->Base.PutMonoRow = put_mono_row_RGB32;
buffer->Base.PutValues = put_values_RGB32;
buffer->Base.PutMonoValues = put_mono_values_RGB32;
break;
case B_RGB24:
buffer->Base.GetRow = get_row_RGB24;
buffer->Base.GetValues = get_values_RGB24;
buffer->Base.PutRow = put_row_RGB24;
buffer->Base.PutRowRGB = put_row_rgb_RGB24;
buffer->Base.PutMonoRow = put_mono_row_RGB24;
buffer->Base.PutValues = put_values_RGB24;
buffer->Base.PutMonoValues = put_mono_values_RGB24;
break;
case B_RGB16:
buffer->Base.GetRow = get_row_RGB16;
buffer->Base.GetValues = get_values_RGB16;
buffer->Base.PutRow = put_row_RGB16;
buffer->Base.PutRowRGB = put_row_rgb_RGB16;
buffer->Base.PutMonoRow = put_mono_row_RGB16;
buffer->Base.PutValues = put_values_RGB16;
buffer->Base.PutMonoValues = put_mono_values_RGB16;
break;
case B_RGB15:
buffer->Base.GetRow = get_row_RGB15;
buffer->Base.GetValues = get_values_RGB15;
buffer->Base.PutRow = put_row_RGB15;
buffer->Base.PutRowRGB = put_row_rgb_RGB15;
buffer->Base.PutMonoRow = put_mono_row_RGB15;
buffer->Base.PutValues = put_values_RGB15;
buffer->Base.PutMonoValues = put_mono_values_RGB15;
break;
case B_CMAP8:
buffer->Base.GetRow = get_row_CMAP8;
buffer->Base.GetValues = get_values_CMAP8;
buffer->Base.PutRow = put_row_CMAP8;
buffer->Base.PutRowRGB = put_row_rgb_CMAP8;
buffer->Base.PutMonoRow = put_mono_row_CMAP8;
buffer->Base.PutValues = put_values_CMAP8;
buffer->Base.PutMonoValues = put_mono_values_CMAP8;
break;
default:
fprintf(stderr, "Unsupported screen color space %d\n", fColorSpace);
debugger("Unsupported OpenGL color space");
break;
}
}
void
MesaSoftwareRenderer::_DeleteBackBuffer(struct gl_renderbuffer* rb)
{
_mesa_free(rb->Data);
_mesa_free(rb);
}

63
src/add-ons/opengl/mesa_software_renderer/MesaSoftwareRenderer.h
View File

@ -5,6 +5,7 @@
* Authors:
* Jérôme Duval, korli@users.berlios.de
* Philippe Houdoin, philippe.houdoin@free.fr
* Artur Wyszynski, harakash@gmail.com
*/
/*
* Mesa 3-D graphics library
@ -21,12 +22,38 @@ extern "C" {
#include "context.h"
struct msr_renderbuffer {
struct gl_renderbuffer Base;
uint32 Size;
};
static INLINE struct msr_renderbuffer*
msr_renderbuffer(struct gl_renderbuffer* rb)
{
return (struct msr_renderbuffer*)rb;
}
struct msr_framebuffer {
struct gl_framebuffer Base;
uint32 Width;
uint32 Height;
};
static INLINE struct msr_framebuffer*
msr_framebuffer(struct gl_framebuffer* rb)
{
return (struct msr_framebuffer*)rb;
}
}
class MesaSoftwareRenderer : public BGLRenderer {
public:
MesaSoftwareRenderer(BGLView* view,
ulong bgl_options,
ulong bgl_options,
BGLDispatcher* dispatcher);
virtual ~MesaSoftwareRenderer();
@ -45,34 +72,38 @@ public:
virtual void DirectConnected(direct_buffer_info* info);
private:
static void Error(GLcontext* ctx);
static const GLubyte* GetString(GLcontext* ctx, GLenum name);
static void Viewport(GLcontext* ctx, GLint x, GLint y,
static void _Error(GLcontext* ctx);
static const GLubyte* _GetString(GLcontext* ctx, GLenum name);
static void _Viewport(GLcontext* ctx, GLint x, GLint y,
GLsizei w, GLsizei h);
static void UpdateState(GLcontext* ctx, GLuint newState);
static void ClearFront(GLcontext* ctx);
static void ClearIndex(GLcontext* ctx, GLuint index);
static void ClearColor(GLcontext* ctx,
const GLfloat color[4]);
static void Clear(GLcontext* ctx, GLbitfield mask);
static GLboolean RenderbufferStorage(GLcontext* ctx,
static void _UpdateState(GLcontext* ctx, GLuint newState);
static void _ClearFront(GLcontext* ctx);
static GLboolean _FrontRenderbufferStorage(GLcontext* ctx,
struct gl_renderbuffer* render,
GLenum internalFormat,
GLuint width, GLuint height);
static void Flush(GLcontext *ctx);
static GLboolean _BackRenderbufferStorage(GLcontext* ctx,
struct gl_renderbuffer* render,
GLenum internalFormat,
GLuint width, GLuint height);
static void _Flush(GLcontext *ctx);
void _SetSpanFuncs(struct msr_renderbuffer* buffer,
color_space colorSpace);
static void _DeleteBackBuffer(struct gl_renderbuffer* rb);
void _AllocateBitmap();
void _AllocateBitmap();
BBitmap* fBitmap;
bool fDirectModeEnabled;
direct_buffer_info* fInfo;
direct_buffer_info* fInfo;
BLocker fInfoLocker;
ulong fOptions;
GLcontext* fContext;
GLvisual* fVisual;
GLframebuffer* fFrameBuffer;
struct gl_renderbuffer* fRenderBuffer;
struct msr_framebuffer* fFrameBuffer;
struct msr_renderbuffer* fFrontRenderBuffer;
struct msr_renderbuffer* fBackRenderBuffer;
GLchan fClearColor[4]; // buffer clear color
GLuint fClearIndex; // buffer clear color index