-/* $Id: GLView.cpp,v 1.6 2002/09/19 16:19:45 brianp Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 3.5
+ * Version: 6.1
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
*/
-/*
- * $Log: GLView.cpp,v $
- * Revision 1.6 2002/09/19 16:19:45 brianp
- * Updated BeOS support (Philippe Houdoin)
- *
- * Revision 1.5 2000/11/17 21:01:26 brianp
- * Minor header file changes to silence warnings.
- * Added _mesa_enable_sw_extensions(), called by software-only drivers
- * to enable all s/w-supported GL extensions.
- *
- * Revision 1.4 2000/11/14 17:51:15 brianp
- * more Driver.Color, Driver.Index updates
- *
- * Revision 1.3 2000/09/26 20:54:09 brianp
- * First batch of OpenGL SI related changes:
- * Renamed struct gl_context to struct __GLcontextRec.
- * Include glcore.h, setup GL imports/exports.
- * Replaced gl_ prefix with _mesa_ prefix in context.[ch] functions.
- * GLcontext's Visual field is no longer a pointer.
- *
- * Revision 1.2 2000/03/19 01:13:13 brianp
- * updated for Mesa 3.3
- *
- * Revision 1.1.1.1 1999/08/19 00:55:41 jtg
- * Imported sources
- *
- * Revision 1.7 1999/03/28 21:08:17 brianp
- * updated SetBuffer driver function
- *
- * Revision 1.6 1999/02/14 03:44:37 brianp
- * new copyright
- *
- * Revision 1.5 1999/02/11 03:50:57 brianp
- * added CopySubBufferMESA()
- *
- * Revision 1.4 1999/02/06 17:44:59 brianp
- * code clean-up and bug fixes
- *
- * Revision 1.3 1999/02/04 04:13:15 brianp
- * implemented double buffering
- *
- * Revision 1.2 1999/02/03 04:23:28 brianp
- * basic device driver functions now work (yeah!)
- *
- * Revision 1.1 1999/02/02 04:40:46 brianp
- * Initial revision
- */
-
-#include "glheader.h"
-
#include <assert.h>
#include <stdio.h>
extern "C" {
+#include "glheader.h"
+#include "version.h"
+#include "buffers.h"
+#include "bufferobj.h"
#include "context.h"
#include "colormac.h"
#include "depth.h"
#include "extensions.h"
#include "macros.h"
#include "matrix.h"
-#include "mem.h"
-#include "mmath.h"
#include "mtypes.h"
#include "texformat.h"
+#include "texobj.h"
+#include "teximage.h"
#include "texstore.h"
-#include "array_cache/acache.h"
+#include "vbo/vbo.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "swrast/s_context.h"
#include "swrast/s_depth.h"
#include "swrast/s_lines.h"
#include "swrast/s_triangle.h"
-#include "swrast/s_trispan.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
+#include "drivers/common/driverfuncs.h"
+
} // extern "C"
+#include <interface/Screen.h>
#include <GLView.h>
// BeOS component ordering for B_RGBA32 bitmap format
-#define BE_RCOMP 2
-#define BE_GCOMP 1
-#define BE_BCOMP 0
-#define BE_ACOMP 3
+#if B_HOST_IS_LENDIAN
+ #define BE_RCOMP 2
+ #define BE_GCOMP 1
+ #define BE_BCOMP 0
+ #define BE_ACOMP 3
-#define PACK_B_RGBA32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
+ #define PACK_B_RGBA32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
(color[RCOMP] << 16) | (color[ACOMP] << 24))
-#define PACK_B_RGB32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
- (color[RCOMP] << 16) | 0xFF000000)
+ #define PACK_B_RGB32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
+ (color[RCOMP] << 16) | 0xFF000000)
+#else
+ // Big Endian B_RGBA32 bitmap format
+ #define BE_RCOMP 1
+ #define BE_GCOMP 2
+ #define BE_BCOMP 3
+ #define BE_ACOMP 0
+
+ #define PACK_B_RGBA32(color) (color[ACOMP] | (color[RCOMP] << 8) | \
+ (color[GCOMP] << 16) | (color[BCOMP] << 24))
+
+ #define PACK_B_RGB32(color) ((color[RCOMP] << 8) | (color[GCOMP] << 16) | \
+ (color[BCOMP] << 24) | 0xFF000000)
+#endif
#define FLIP(coord) (LIBGGI_MODE(ggi_ctx->ggi_visual)->visible.y-(coord) - 1)
+const char * color_space_name(color_space space);
+
//
// This object hangs off of the BGLView object. We have to use
// Be's BGLView class as-is to maintain binary compatibility (we
//
class MesaDriver
{
+friend class BGLView;
public:
MesaDriver();
~MesaDriver();
- void Init(BGLView * bglview, GLcontext * c, GLvisual * v, GLframebuffer * b);
+
+ void Init(BGLView * bglview, struct gl_context * c, struct gl_config * v, struct gl_framebuffer * b);
+
+ void LockGL();
+ void UnlockGL();
+ void SwapBuffers() const;
+ status_t CopyPixelsOut(BPoint source, BBitmap *dest);
+ status_t CopyPixelsIn(BBitmap *source, BPoint dest);
- void LockGL();
- void UnlockGL();
- void SwapBuffers() const;
void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const;
void Draw(BRect updateRect) const;
MesaDriver(const MesaDriver &rhs); // copy constructor illegal
MesaDriver &operator=(const MesaDriver &rhs); // assignment oper. illegal
- GLcontext * m_glcontext;
- GLvisual * m_glvisual;
- GLframebuffer * m_glframebuffer;
+ struct gl_context * m_glcontext;
+ struct gl_config * m_glvisual;
+ struct gl_framebuffer * m_glframebuffer;
BGLView * m_bglview;
BBitmap * m_bitmap;
- GLubyte m_clear_color[4]; // buffer clear color
+ GLchan m_clear_color[4]; // buffer clear color
GLuint m_clear_index; // buffer clear color index
GLint m_bottom; // used for flipping Y coords
GLuint m_width;
GLuint m_height;
- // Mesa Device Driver functions
- static void UpdateState(GLcontext *ctx, GLuint new_state);
- static void ClearIndex(GLcontext *ctx, GLuint index);
- static void ClearColor(GLcontext *ctx, const GLchan color[4]);
- static void Clear(GLcontext *ctx, GLbitfield mask,
+ // Mesa Device Driver callback functions
+ static void UpdateState(struct gl_context *ctx, GLuint new_state);
+ static void ClearIndex(struct gl_context *ctx, GLuint index);
+ static void ClearColor(struct gl_context *ctx, const GLfloat color[4]);
+ static void Clear(struct gl_context *ctx, GLbitfield mask,
GLboolean all, GLint x, GLint y,
GLint width, GLint height);
- static void ClearFront(GLcontext *ctx, GLboolean all, GLint x, GLint y,
+ static void ClearFront(struct gl_context *ctx, GLboolean all, GLint x, GLint y,
GLint width, GLint height);
- static void ClearBack(GLcontext *ctx, GLboolean all, GLint x, GLint y,
+ static void ClearBack(struct gl_context *ctx, GLboolean all, GLint x, GLint y,
GLint width, GLint height);
- static void Index(GLcontext *ctx, GLuint index);
- static void Color(GLcontext *ctx, GLubyte r, GLubyte g,
+ static void Index(struct gl_context *ctx, GLuint index);
+ static void Color(struct gl_context *ctx, GLubyte r, GLubyte g,
GLubyte b, GLubyte a);
- static void SetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
+ static void SetBuffer(struct gl_context *ctx, struct gl_framebuffer *colorBuffer,
GLenum mode);
- static void GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
+ static void GetBufferSize(struct gl_framebuffer * framebuffer, GLuint *width,
GLuint *height);
- static const GLubyte * GetString(GLcontext *ctx, GLenum name);
+ static void Error(struct gl_context *ctx);
+ static const GLubyte * GetString(struct gl_context *ctx, GLenum name);
+ static void Viewport(struct gl_context *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
// Front-buffer functions
- static void WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+ static void WriteRGBASpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][4],
const GLubyte mask[]);
- static void WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+ static void WriteRGBSpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][3],
const GLubyte mask[]);
- static void WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+ static void WriteMonoRGBASpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLchan color[4],
const GLubyte mask[]);
- static void WriteRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+ static void WriteRGBAPixelsFront(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
CONST GLubyte rgba[][4],
const GLubyte mask[]);
- static void WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+ static void WriteMonoRGBAPixelsFront(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLchan color[4],
const GLubyte mask[]);
- static void WriteCI32SpanFront(const GLcontext *ctx, GLuint n,
+ static void WriteCI32SpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLuint index[], const GLubyte mask[]);
- static void WriteCI8SpanFront(const GLcontext *ctx, GLuint n,
+ static void WriteCI8SpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLubyte index[], const GLubyte mask[]);
- static void WriteMonoCISpanFront(const GLcontext *ctx, GLuint n,
+ static void WriteMonoCISpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
GLuint colorIndex, const GLubyte mask[]);
- static void WriteCI32PixelsFront(const GLcontext *ctx,
+ static void WriteCI32PixelsFront(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLuint index[], const GLubyte mask[]);
- static void WriteMonoCIPixelsFront(const GLcontext *ctx, GLuint n,
+ static void WriteMonoCIPixelsFront(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[]);
- static void ReadCI32SpanFront(const GLcontext *ctx,
+ static void ReadCI32SpanFront(const struct gl_context *ctx,
GLuint n, GLint x, GLint y, GLuint index[]);
- static void ReadRGBASpanFront(const GLcontext *ctx, GLuint n,
+ static void ReadRGBASpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
GLubyte rgba[][4]);
- static void ReadCI32PixelsFront(const GLcontext *ctx,
+ static void ReadCI32PixelsFront(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[]);
- static void ReadRGBAPixelsFront(const GLcontext *ctx,
+ static void ReadRGBAPixelsFront(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte rgba[][4], const GLubyte mask[]);
// Back buffer functions
- static void WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
+ static void WriteRGBASpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][4],
const GLubyte mask[]);
- static void WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
+ static void WriteRGBSpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][3],
const GLubyte mask[]);
- static void WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
+ static void WriteMonoRGBASpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLchan color[4],
const GLubyte mask[]);
- static void WriteRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+ static void WriteRGBAPixelsBack(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
CONST GLubyte rgba[][4],
const GLubyte mask[]);
- static void WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+ static void WriteMonoRGBAPixelsBack(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLchan color[4],
const GLubyte mask[]);
- static void WriteCI32SpanBack(const GLcontext *ctx, GLuint n,
+ static void WriteCI32SpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLuint index[], const GLubyte mask[]);
- static void WriteCI8SpanBack(const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ static void WriteCI8SpanBack(const struct gl_context *ctx, GLuint n, GLint x, GLint y,
const GLubyte index[], const GLubyte mask[]);
- static void WriteMonoCISpanBack(const GLcontext *ctx, GLuint n,
+ static void WriteMonoCISpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y, GLuint colorIndex,
const GLubyte mask[]);
- static void WriteCI32PixelsBack(const GLcontext *ctx,
+ static void WriteCI32PixelsBack(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
const GLuint index[], const GLubyte mask[]);
- static void WriteMonoCIPixelsBack(const GLcontext *ctx,
+ static void WriteMonoCIPixelsBack(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[]);
- static void ReadCI32SpanBack(const GLcontext *ctx,
+ static void ReadCI32SpanBack(const struct gl_context *ctx,
GLuint n, GLint x, GLint y, GLuint index[]);
- static void ReadRGBASpanBack(const GLcontext *ctx, GLuint n,
+ static void ReadRGBASpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
GLubyte rgba[][4]);
- static void ReadCI32PixelsBack(const GLcontext *ctx,
+ static void ReadCI32PixelsBack(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[]);
- static void ReadRGBAPixelsBack(const GLcontext *ctx,
+ static void ReadRGBAPixelsBack(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte rgba[][4], const GLubyte mask[]);
BGLView::BGLView(BRect rect, char *name,
ulong resizingMode, ulong mode,
ulong options)
- :BView(rect, name, resizingMode, mode | B_WILL_DRAW | B_FRAME_EVENTS) // | B_FULL_UPDATE_ON_RESIZE)
+ : BView(rect, name, B_FOLLOW_ALL_SIDES, mode | B_WILL_DRAW | B_FRAME_EVENTS) // | B_FULL_UPDATE_ON_RESIZE)
{
- const GLboolean rgbFlag = (options & BGL_RGB) == BGL_RGB;
- const GLboolean alphaFlag = (options & BGL_ALPHA) == BGL_ALPHA;
- const GLboolean dblFlag = (options & BGL_DOUBLE) == BGL_DOUBLE;
+ // We don't support single buffering (yet): double buffering forced.
+ options |= BGL_DOUBLE;
+
+ const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
+ const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
+ 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;
const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
const GLint index = (options & BGL_INDEX) ? 32 : 0;
- const GLint red = (options & BGL_RGB) ? 8 : 0;
- const GLint green = (options & BGL_RGB) ? 8 : 0;
- const GLint blue = (options & BGL_RGB) ? 8 : 0;
- const GLint alpha = (options & BGL_RGB) ? 8 : 0;
+ const GLint red = rgbFlag ? 8 : 0;
+ const GLint green = rgbFlag ? 8 : 0;
+ const GLint blue = rgbFlag ? 8 : 0;
+ const GLint alpha = alphaFlag ? 8 : 0;
+
+ m_options = options | BGL_INDIRECT;
+ struct dd_function_table functions;
+
if (!rgbFlag) {
fprintf(stderr, "Mesa Warning: color index mode not supported\n");
}
// Allocate auxiliary data object
- MesaDriver * md = new MesaDriver;
+ MesaDriver * md = new MesaDriver();
// examine option flags and create gl_context struct
- GLvisual * visual = _mesa_create_visual( rgbFlag,
- dblFlag,
+ struct gl_config * visual = _mesa_create_visual( dblFlag,
stereoFlag,
red, green, blue, alpha,
- index,
depth,
stencil,
accum, accum, accum, accum,
1
);
+ // Initialize device driver function table
+ _mesa_init_driver_functions(&functions);
+
+ functions.GetString = md->GetString;
+ functions.UpdateState = md->UpdateState;
+ functions.GetBufferSize = md->GetBufferSize;
+ functions.Clear = md->Clear;
+ functions.ClearIndex = md->ClearIndex;
+ functions.ClearColor = md->ClearColor;
+ functions.Error = md->Error;
+ functions.Viewport = md->Viewport;
+
// create core context
- __GLimports imports;
- _mesa_init_default_imports(&imports, md);
- GLcontext * ctx = _mesa_create_context( visual, NULL, &imports);
+ struct gl_context *ctx = _mesa_create_context(API_OPENGL, visual,
+ NULL, &functions, md);
+ if (! ctx) {
+ _mesa_destroy_visual(visual);
+ delete md;
+ return;
+ }
+ _mesa_enable_sw_extensions(ctx);
+ _mesa_enable_1_3_extensions(ctx);
+ _mesa_enable_1_4_extensions(ctx);
+ _mesa_enable_1_5_extensions(ctx);
// create core framebuffer
- GLframebuffer * buffer = _mesa_create_framebuffer(visual,
+ struct gl_framebuffer * buffer = _mesa_create_framebuffer(visual,
depth > 0 ? GL_TRUE : GL_FALSE,
stencil > 0 ? GL_TRUE: GL_FALSE,
accum > 0 ? GL_TRUE : GL_FALSE,
alphaFlag
);
- _mesa_enable_sw_extensions(ctx);
- _mesa_enable_1_3_extensions(ctx);
-
/* Initialize the software rasterizer and helper modules.
- */
-
- _swrast_CreateContext(ctx);
- _ac_CreateContext(ctx);
- _tnl_CreateContext(ctx);
- _swsetup_CreateContext(ctx);
-
- _swsetup_Wakeup(ctx);
+ */
+ _swrast_CreateContext(ctx);
+ _vbo_CreateContext(ctx);
+ _tnl_CreateContext(ctx);
+ _swsetup_CreateContext(ctx);
+ _swsetup_Wakeup(ctx);
md->Init(this, ctx, visual, buffer );
// Hook aux data into BGLView object
m_gc = md;
+
+ // some stupid applications (Quake2) don't even think about calling LockGL()
+ // before using glGetString and 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();
+ }
+
}
BGLView::~BGLView()
{
- printf("BGLView destructor\n");
+ // printf("BGLView destructor\n");
MesaDriver * md = (MesaDriver *) m_gc;
assert(md);
delete md;
void BGLView::SwapBuffers()
{
- MesaDriver * md = (MesaDriver *) m_gc;
- assert(md);
- md->SwapBuffers();
+ SwapBuffers(false);
+}
+
+void BGLView::SwapBuffers(bool vSync)
+{
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->SwapBuffers();
+
+ if (vSync) {
+ BScreen screen(Window());
+ screen.WaitForRetrace();
+ }
}
+#if 0
void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height)
{
MesaDriver * md = (MesaDriver *) m_gc;
assert(md);
md->CopySubBuffer(x, y, width, height);
}
-
+#endif
BView * BGLView::EmbeddedView()
{
- // XXX to do
return NULL;
}
status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
{
- // XXX to do
- printf("BGLView::CopyPixelsOut() not implemented yet!\n");
- return B_UNSUPPORTED;
-}
+ if (! dest || ! dest->Bounds().IsValid())
+ return B_BAD_VALUE;
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ return md->CopyPixelsOut(source, dest);
+}
status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
{
- // XXX to do
- printf("BGLView::CopyPixelsIn() not implemented yet!\n");
- return B_UNSUPPORTED;
+ if (! source || ! source->Bounds().IsValid())
+ return B_BAD_VALUE;
+
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ return md->CopyPixelsIn(source, dest);
}
-void BGLView::ErrorCallback(unsigned long errorCode) // GLenum errorCode)
+
+void BGLView::ErrorCallback(unsigned long errorCode) // Mesa's GLenum is not ulong but uint!
{
- // XXX to do
- printf("BGLView::ErrorCallback() not implemented yet!\n");
+ char msg[32];
+ sprintf(msg, "GL: Error code $%04lx.", errorCode);
+ // debugger(msg);
+ fprintf(stderr, "%s\n", msg);
return;
}
void BGLView::Show()
{
-// printf("BGLView Show\n");
BView::Show();
}
void BGLView::Hide()
{
-// printf("BGLView Hide\n");
BView::Hide();
}
void BGLView::DirectConnected( direct_buffer_info *info )
{
- // XXX to do
+#if 0
+ if (! m_direct_connected && m_direct_connection_disabled)
+ return;
+
+ direct_info_locker->Lock();
+ switch(info->buffer_state & B_DIRECT_MODE_MASK) {
+ case B_DIRECT_START:
+ m_direct_connected = true;
+ case B_DIRECT_MODIFY:
+ // Get clipping information
+ if (m_clip_list)
+ free(m_clip_list);
+ m_clip_list_count = info->clip_list_count;
+ m_clip_list = (clipping_rect *) malloc(m_clip_list_count*sizeof(clipping_rect));
+ if (m_clip_list) {
+ memcpy(m_clip_list, info->clip_list, m_clip_list_count*sizeof(clipping_rect));
+ fBits = (uint8 *) info->bits;
+ fRowBytes = info->bytes_per_row;
+ fFormat = info->pixel_format;
+ fBounds = info->window_bounds;
+ fDirty = true;
+ }
+ break;
+ case B_DIRECT_STOP:
+ fConnected = false;
+ break;
+ }
+ direct_info_locker->Unlock();
+#endif
}
void BGLView::EnableDirectMode( bool enabled )
{
- // XXX to do
+ // TODO
}
-
-//---- private methods ----------
+//---- virtual reserved methods ----------
void BGLView::_ReservedGLView1() {}
void BGLView::_ReservedGLView2() {}
void BGLView::_ReservedGLView8() {}
#if 0
+// Not implemented!!!
+
BGLView::BGLView(const BGLView &v)
: BView(v)
{
// XXX not sure how this should work
printf("Warning BGLView::copy constructor not implemented\n");
}
-#endif
-
BGLView &BGLView::operator=(const BGLView &v)
{
printf("Warning BGLView::operator= not implemented\n");
return *this;
}
+#endif
void BGLView::dither_front()
{
_mesa_destroy_visual(m_glvisual);
_mesa_destroy_framebuffer(m_glframebuffer);
_mesa_destroy_context(m_glcontext);
-
+
+ delete m_bitmap;
}
-void MesaDriver::Init(BGLView * bglview, GLcontext * ctx, GLvisual * visual, GLframebuffer * framebuffer)
+void MesaDriver::Init(BGLView * bglview, struct gl_context * ctx, struct gl_config * visual, struct gl_framebuffer * framebuffer)
{
m_bglview = bglview;
m_glcontext = ctx;
TNLcontext * tnl = TNL_CONTEXT(ctx);
assert(md->m_glcontext == ctx );
+ assert(tnl);
+ assert(swdd);
- ctx->Driver.GetString = MesaDriver::GetString;
- ctx->Driver.UpdateState = MesaDriver::UpdateState;
- ctx->Driver.GetBufferSize = MesaDriver::GetBufferSize;
- ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
-
- ctx->Driver.Accum = _swrast_Accum;
- ctx->Driver.Bitmap = _swrast_Bitmap;
- ctx->Driver.ClearIndex = MesaDriver::ClearIndex;
- ctx->Driver.ClearColor = MesaDriver::ClearColor;
- ctx->Driver.Clear = MesaDriver::Clear;
- ctx->Driver.CopyPixels = _swrast_CopyPixels;
- ctx->Driver.DrawPixels = _swrast_DrawPixels;
- ctx->Driver.ReadPixels = _swrast_ReadPixels;
-
- ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
- ctx->Driver.TexImage1D = _mesa_store_teximage1d;
- ctx->Driver.TexImage2D = _mesa_store_teximage2d;
- ctx->Driver.TexImage3D = _mesa_store_teximage3d;
- ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
- ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
- ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
- ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
-
- ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
- ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
- ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
- ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
- ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
- ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
- ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
- ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
- ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
-
- ctx->Driver.BaseCompressedTexFormat = _mesa_base_compressed_texformat;
- ctx->Driver.CompressedTextureSize = _mesa_compressed_texture_size;
- ctx->Driver.GetCompressedTexImage = _mesa_get_compressed_teximage;
-
- swdd->SetBuffer = MesaDriver::SetBuffer;
-
+ // Use default TCL pipeline
tnl->Driver.RunPipeline = _tnl_run_pipeline;
-
- _swsetup_Wakeup(ctx);
+
+ swdd->SetBuffer = this->SetBuffer;
}
void MesaDriver::UnlockGL()
{
- m_bglview->UnlockLooper();
+ if (m_bglview->Looper()->IsLocked())
+ m_bglview->UnlockLooper();
// Could call _mesa_make_current(NULL, NULL) but it would just
// hinder performance
}
void MesaDriver::SwapBuffers() const
{
- // _mesa_swap_buffers();
+ _mesa_notifySwapBuffers(m_glcontext);
if (m_bitmap) {
m_bglview->LockLooper();
- m_bglview->DrawBitmap(m_bitmap, BPoint(0, 0));
+ m_bglview->DrawBitmap(m_bitmap);
m_bglview->UnlockLooper();
};
}
}
}
+status_t MesaDriver::CopyPixelsOut(BPoint location, BBitmap *bitmap)
+{
+ color_space scs = m_bitmap->ColorSpace();
+ color_space dcs = bitmap->ColorSpace();
+
+ if (scs != dcs && (scs != B_RGBA32 || dcs != B_RGB32)) {
+ printf("CopyPixelsOut(): incompatible color space: %s != %s\n",
+ color_space_name(scs),
+ color_space_name(dcs));
+ return B_BAD_TYPE;
+ }
+
+ // debugger("CopyPixelsOut()");
+
+ BRect sr = m_bitmap->Bounds();
+ BRect dr = bitmap->Bounds();
+
+ sr = sr & dr.OffsetBySelf(location);
+ dr = sr.OffsetByCopy(-location.x, -location.y);
+
+ uint8 *ps = (uint8 *) m_bitmap->Bits();
+ uint8 *pd = (uint8 *) bitmap->Bits();
+ uint32 *s, *d;
+ uint32 y;
+ for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
+ s = (uint32 *) (ps + y * m_bitmap->BytesPerRow());
+ s += (uint32) sr.left;
+
+ d = (uint32 *) (pd + (y + (uint32) (dr.top - sr.top)) * bitmap->BytesPerRow());
+ d += (uint32) dr.left;
+
+ memcpy(d, s, dr.IntegerWidth() * 4);
+ }
+ return B_OK;
+}
+
+status_t MesaDriver::CopyPixelsIn(BBitmap *bitmap, BPoint location)
+{
+ color_space scs = bitmap->ColorSpace();
+ color_space dcs = m_bitmap->ColorSpace();
+
+ if (scs != dcs && (dcs != B_RGBA32 || scs != B_RGB32)) {
+ printf("CopyPixelsIn(): incompatible color space: %s != %s\n",
+ color_space_name(scs),
+ color_space_name(dcs));
+ return B_BAD_TYPE;
+ }
+
+ // debugger("CopyPixelsIn()");
+
+ BRect sr = bitmap->Bounds();
+ BRect dr = m_bitmap->Bounds();
+
+ sr = sr & dr.OffsetBySelf(location);
+ dr = sr.OffsetByCopy(-location.x, -location.y);
+
+ uint8 *ps = (uint8 *) bitmap->Bits();
+ uint8 *pd = (uint8 *) m_bitmap->Bits();
+ uint32 *s, *d;
+ uint32 y;
+ for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
+ s = (uint32 *) (ps + y * bitmap->BytesPerRow());
+ s += (uint32) sr.left;
+
+ d = (uint32 *) (pd + (y + (uint32) (dr.top - sr.top)) * m_bitmap->BytesPerRow());
+ d += (uint32) dr.left;
+
+ memcpy(d, s, dr.IntegerWidth() * 4);
+ }
+ return B_OK;
+}
+
void MesaDriver::Draw(BRect updateRect) const
{
}
-void MesaDriver::UpdateState( GLcontext *ctx, GLuint new_state )
+void MesaDriver::Error(struct gl_context *ctx)
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ if (md && md->m_bglview)
+ md->m_bglview->ErrorCallback((unsigned long) ctx->ErrorValue);
+}
+
+void MesaDriver::UpdateState( struct gl_context *ctx, GLuint new_state )
{
struct swrast_device_driver * swdd = _swrast_GetDeviceDriverReference( ctx );
_swrast_InvalidateState( ctx, new_state );
_swsetup_InvalidateState( ctx, new_state );
- _ac_InvalidateState( ctx, new_state );
+ _vbo_InvalidateState( ctx, new_state );
_tnl_InvalidateState( ctx, new_state );
- if (ctx->Color.DrawBuffer == GL_FRONT) {
+ if (ctx->Color.DrawBuffer[0] == GL_FRONT) {
/* read/write front buffer */
swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanFront;
swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanFront;
}
-void MesaDriver::ClearIndex(GLcontext *ctx, GLuint index)
+void MesaDriver::ClearIndex(struct gl_context *ctx, GLuint index)
{
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
md->m_clear_index = index;
}
-void MesaDriver::ClearColor(GLcontext *ctx, const GLchan color[4])
- // GLubyte r, GLubyte g,
- // GLubyte b, GLubyte a)
+void MesaDriver::ClearColor(struct gl_context *ctx, const GLfloat color[4])
{
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
- md->m_clear_color[BE_RCOMP] = color[0];
- md->m_clear_color[BE_GCOMP] = color[1];
- md->m_clear_color[BE_BCOMP] = color[2];
- md->m_clear_color[BE_ACOMP] = color[3];
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_RCOMP], color[0]);
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_GCOMP], color[1]);
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_BCOMP], color[2]);
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_ACOMP], color[3]);
assert(md->m_bglview);
}
-void MesaDriver::Clear(GLcontext *ctx, GLbitfield mask,
+void MesaDriver::Clear(struct gl_context *ctx, GLbitfield mask,
GLboolean all, GLint x, GLint y,
GLint width, GLint height)
{
}
-void MesaDriver::ClearFront(GLcontext *ctx,
+void MesaDriver::ClearFront(struct gl_context *ctx,
GLboolean all, GLint x, GLint y,
GLint width, GLint height)
{
}
-void MesaDriver::ClearBack(GLcontext *ctx,
+void MesaDriver::ClearBack(struct gl_context *ctx,
GLboolean all, GLint x, GLint y,
GLint width, GLint height)
{
assert(bitmap);
GLuint *start = (GLuint *) bitmap->Bits();
const GLuint *clearPixelPtr = (const GLuint *) md->m_clear_color;
- const GLuint clearPixel = *clearPixelPtr;
+ const GLuint clearPixel = B_LENDIAN_TO_HOST_INT32(*clearPixelPtr);
if (all) {
const int numPixels = md->m_width * md->m_height;
}
-void MesaDriver::SetBuffer(GLcontext *ctx, GLframebuffer *buffer,
+void MesaDriver::SetBuffer(struct gl_context *ctx, struct gl_framebuffer *buffer,
GLenum mode)
{
/* TODO */
(void) mode;
}
-void MesaDriver::GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
+void MesaDriver::GetBufferSize(struct gl_framebuffer * framebuffer, GLuint *width,
GLuint *height)
{
GET_CURRENT_CONTEXT(ctx);
}
-const GLubyte *MesaDriver::GetString(GLcontext *ctx, GLenum name)
+void MesaDriver::Viewport(struct gl_context *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ /* poll for window size change and realloc software Z/stencil/etc if needed */
+ _mesa_ResizeBuffersMESA();
+}
+
+
+const GLubyte *MesaDriver::GetString(struct gl_context *ctx, GLenum name)
{
switch (name) {
case GL_RENDERER:
- return (const GLubyte *) "Mesa BGLView (software)";
+ return (const GLubyte *) "Mesa " MESA_VERSION_STRING " powered BGLView (software)";
default:
// Let core library handle all other cases
return NULL;
// Plot a pixel. (0,0) is upper-left corner
// This is only used when drawing to the front buffer.
-static void Plot(BGLView *bglview, int x, int y)
+inline void Plot(BGLView *bglview, int x, int y)
{
// XXX There's got to be a better way!
BPoint p(x, y), q(x+1, y);
}
-void MesaDriver::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBASpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][4],
const GLubyte mask[])
}
}
-void MesaDriver::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBSpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][3],
const GLubyte mask[])
}
}
-void MesaDriver::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBASpanFront(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLchan color[4],
const GLubyte mask[])
}
}
-void MesaDriver::WriteRGBAPixelsFront(const GLcontext *ctx,
+void MesaDriver::WriteRGBAPixelsFront(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
CONST GLubyte rgba[][4],
const GLubyte mask[] )
}
-void MesaDriver::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBAPixelsFront(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLchan color[4],
const GLubyte mask[])
}
-void MesaDriver::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+void MesaDriver::WriteCI32SpanFront( const struct gl_context *ctx, GLuint n, GLint x, GLint y,
const GLuint index[], const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteCI32SpanFront() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteCI8SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+void MesaDriver::WriteCI8SpanFront( const struct gl_context *ctx, GLuint n, GLint x, GLint y,
const GLubyte index[], const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteCI8SpanFront() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCISpanFront( const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCISpanFront() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI32PixelsFront( const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLuint index[], const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteCI32PixelsFront() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCIPixelsFront( const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCIPixelsFront() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::ReadCI32SpanFront( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanFront( const struct gl_context *ctx,
GLuint n, GLint x, GLint y, GLuint index[] )
{
printf("ReadCI32SpanFront() not implemented yet!\n");
- // XXX to do
+ // TODO
}
-void MesaDriver::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanFront( const struct gl_context *ctx, GLuint n,
GLint x, GLint y, GLubyte rgba[][4] )
{
printf("ReadRGBASpanFront() not implemented yet!\n");
- // XXX to do
+ // TODO
}
-void MesaDriver::ReadCI32PixelsFront( const GLcontext *ctx,
+void MesaDriver::ReadCI32PixelsFront( const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] )
{
printf("ReadCI32PixelsFront() not implemented yet!\n");
- // XXX to do
+ // TODO
}
-void MesaDriver::ReadRGBAPixelsFront( const GLcontext *ctx,
+void MesaDriver::ReadRGBAPixelsFront( const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte rgba[][4], const GLubyte mask[] )
{
printf("ReadRGBAPixelsFront() not implemented yet!\n");
- // XXX to do
+ // TODO
}
-void MesaDriver::WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBASpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgba[][4],
const GLubyte mask[])
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
BBitmap *bitmap = md->m_bitmap;
- static bool already_called = false;
- if (! already_called) {
- printf("WriteRGBASpanBack() called.\n");
- already_called = true;
- }
-
assert(bitmap);
int row = md->m_bottom - y;
}
-void MesaDriver::WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBSpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
CONST GLubyte rgb[][3],
const GLubyte mask[])
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
BBitmap *bitmap = md->m_bitmap;
- static bool already_called = false;
- if (! already_called) {
- printf("WriteRGBSpanBack() called.\n");
- already_called = true;
- }
-
assert(bitmap);
int row = md->m_bottom - y;
-void MesaDriver::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBASpanBack(const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLchan color[4], const GLubyte mask[])
{
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
BBitmap *bitmap = md->m_bitmap;
- static bool already_called = false;
- if (! already_called) {
- printf("WriteMonoRGBASpanBack() called.\n");
- already_called = true;
- }
-
assert(bitmap);
int row = md->m_bottom - y;
}
-void MesaDriver::WriteRGBAPixelsBack(const GLcontext *ctx,
+void MesaDriver::WriteRGBAPixelsBack(const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
CONST GLubyte rgba[][4],
const GLubyte mask[] )
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
BBitmap *bitmap = md->m_bitmap;
- static bool already_called = false;
- if (! already_called) {
- printf("WriteRGBAPixelsBack() called.\n");
- already_called = true;
- }
-
assert(bitmap);
#if 0
while(n--) {
}
-void MesaDriver::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBAPixelsBack(const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLchan color[4],
const GLubyte mask[])
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
BBitmap *bitmap = md->m_bitmap;
- static bool already_called = false;
- if (! already_called) {
- printf("WriteMonoRGBAPixelsBack() called.\n");
- already_called = true;
- }
-
assert(bitmap);
uint32 pixel_color = PACK_B_RGBA32(color);
}
-void MesaDriver::WriteCI32SpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI32SpanBack( const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLuint index[], const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteCI32SpanBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteCI8SpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI8SpanBack( const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
const GLubyte index[], const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteCI8SpanBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCISpanBack( const struct gl_context *ctx, GLuint n,
GLint x, GLint y,
GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCISpanBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI32PixelsBack( const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLuint index[], const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteCI32PixelsBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCIPixelsBack( const struct gl_context *ctx, GLuint n,
const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCIPixelsBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::ReadCI32SpanBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanBack( const struct gl_context *ctx,
GLuint n, GLint x, GLint y, GLuint index[] )
{
- // XXX to do
+ printf("ReadCI32SpanBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanBack( const struct gl_context *ctx, GLuint n,
GLint x, GLint y, GLubyte rgba[][4] )
{
MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
}
-void MesaDriver::ReadCI32PixelsBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32PixelsBack( const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] )
{
- // XXX to do
+ printf("ReadCI32PixelsBack() not implemented yet!\n");
+ // TODO
}
-void MesaDriver::ReadRGBAPixelsBack( const GLcontext *ctx,
+void MesaDriver::ReadRGBAPixelsBack( const struct gl_context *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte rgba[][4], const GLubyte mask[] )
{
};
}
+const char * color_space_name(color_space space)
+{
+#define C2N(a) case a: return #a
+
+ switch (space) {
+ C2N(B_RGB24);
+ C2N(B_RGB32);
+ C2N(B_RGBA32);
+ C2N(B_RGB32_BIG);
+ C2N(B_RGBA32_BIG);
+ C2N(B_GRAY8);
+ C2N(B_GRAY1);
+ C2N(B_RGB16);
+ C2N(B_RGB15);
+ C2N(B_RGBA15);
+ C2N(B_CMAP8);
+ default:
+ return "Unknown!";
+ };
+
+#undef C2N
+};
projects / mesa.git / blobdiff