X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fbeos%2FGLView.cpp;h=43aa13e70103d8a0fcb75d93cf49799982223ff8;hb=a2c2393d9185030bded93311880a770aa62f931d;hp=44e51a58dbb1837931e1b1aa4a1f7fa97d1fcb25;hpb=4fae0260a6b9f73bbca8959b6d8f04fb43426a45;p=mesa.git diff --git a/src/mesa/drivers/beos/GLView.cpp b/src/mesa/drivers/beos/GLView.cpp index 44e51a58dbb..43aa13e7010 100644 --- a/src/mesa/drivers/beos/GLView.cpp +++ b/src/mesa/drivers/beos/GLView.cpp @@ -1,10 +1,8 @@ -/* $Id: GLView.cpp,v 1.4 2000/11/14 17:51:15 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"), @@ -25,60 +23,74 @@ */ -/* - * $Log: GLView.cpp,v $ - * 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 #include -#include -#include "../src/context.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 "mtypes.h" +#include "texformat.h" +#include "texobj.h" +#include "teximage.h" +#include "texstore.h" +#include "array_cache/acache.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 +#include // 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) | \ + (color[RCOMP] << 16) | (color[ACOMP] << 24)) + + #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 @@ -86,1185 +98,1469 @@ // can't add new members to it). Instead we just put all our data // in this class and use BGLVIew::m_gc to point to it. // -class AuxInfo +class MesaDriver { +friend class BGLView; public: - AuxInfo(); - ~AuxInfo(); - void Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b); + MesaDriver(); + ~MesaDriver(); + + void Init(BGLView * bglview, GLcontext * c, GLvisual * v, GLframebuffer * b); - void MakeCurrent(); - void SwapBuffers() const; - void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const; + void LockGL(); + void UnlockGL(); + void SwapBuffers() const; + status_t CopyPixelsOut(BPoint source, BBitmap *dest); + status_t CopyPixelsIn(BBitmap *source, BPoint dest); + + void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const; + void Draw(BRect updateRect) const; private: - AuxInfo(const AuxInfo &rhs); // copy constructor illegal - AuxInfo &operator=(const AuxInfo &rhs); // assignment oper. illegal - - GLcontext *mContext; - GLvisual *mVisual; - GLframebuffer *mBuffer; - - BGLView *mBGLView; - BBitmap *mBitmap; - - GLubyte mClearColor[4]; // buffer clear color - GLuint mClearIndex; // buffer clear color index - GLint mBottom; // used for flipping Y coords - GLint mWidth, mHeight; // size of buffer - - // Mesa device driver functions - static void UpdateState(GLcontext *ctx); - static void ClearIndex(GLcontext *ctx, GLuint index); - static void ClearColor(GLcontext *ctx, GLubyte r, GLubyte g, - GLubyte b, GLubyte a); - static GLbitfield Clear(GLcontext *ctx, GLbitfield mask, + MesaDriver(const MesaDriver &rhs); // copy constructor illegal + MesaDriver &operator=(const MesaDriver &rhs); // assignment oper. illegal + + GLcontext * m_glcontext; + GLvisual * m_glvisual; + GLframebuffer * m_glframebuffer; + + BGLView * m_bglview; + BBitmap * m_bitmap; + + 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 callback functions + static void UpdateState(GLcontext *ctx, GLuint new_state); + static void ClearIndex(GLcontext *ctx, GLuint index); + static void ClearColor(GLcontext *ctx, const GLfloat color[4]); + static void Clear(GLcontext *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(GLcontext *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(GLcontext *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(GLcontext *ctx, GLuint index); + static void Color(GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a); - static GLboolean SetDrawBuffer(GLcontext *ctx, GLenum mode); - static void SetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, + static void SetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, GLenum mode); - static void GetBufferSize(GLcontext *ctgx, GLuint *width, + static void GetBufferSize(GLframebuffer * framebuffer, GLuint *width, GLuint *height); - static const GLubyte *GetString(GLcontext *ctx, GLenum name); + static void Error(GLcontext *ctx); + static const GLubyte * GetString(GLcontext *ctx, GLenum name); // Front-buffer functions - static void WriteRGBASpanFront(const GLcontext *ctx, GLuint n, + static void WriteRGBASpanFront(const GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *ctx, GLuint n, GLint x, GLint y, GLuint colorIndex, const GLubyte mask[]); - static void WriteCI32PixelsFront(const GLcontext *ctx, + static void WriteCI32PixelsFront(const GLcontext *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 GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLuint colorIndex, const GLubyte mask[]); - static void ReadCI32SpanFront(const GLcontext *ctx, + static void ReadCI32SpanFront(const GLcontext *ctx, GLuint n, GLint x, GLint y, GLuint index[]); - static void ReadRGBASpanFront(const GLcontext *ctx, GLuint n, + static void ReadRGBASpanFront(const GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte rgba[][4]); - static void ReadCI32PixelsFront(const GLcontext *ctx, + static void ReadCI32PixelsFront(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLuint indx[], const GLubyte mask[]); - static void ReadRGBAPixelsFront(const GLcontext *ctx, + static void ReadRGBAPixelsFront(const GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *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 GLcontext *ctx, GLuint n, GLint x, GLint y, GLuint colorIndex, const GLubyte mask[]); - static void WriteCI32PixelsBack(const GLcontext *ctx, + static void WriteCI32PixelsBack(const GLcontext *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 GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLuint colorIndex, const GLubyte mask[]); - static void ReadCI32SpanBack(const GLcontext *ctx, + static void ReadCI32SpanBack(const GLcontext *ctx, GLuint n, GLint x, GLint y, GLuint index[]); - static void ReadRGBASpanBack(const GLcontext *ctx, GLuint n, + static void ReadRGBASpanBack(const GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte rgba[][4]); - static void ReadCI32PixelsBack(const GLcontext *ctx, + static void ReadCI32PixelsBack(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLuint indx[], const GLubyte mask[]); - static void ReadRGBAPixelsBack(const GLcontext *ctx, + static void ReadRGBAPixelsBack(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte rgba[][4], const GLubyte mask[]); }; +//------------------------------------------------------------------ +// Public interface methods +//------------------------------------------------------------------ -AuxInfo::AuxInfo() +// +// Input: rect - initial rectangle +// name - window name +// resizingMode - example: B_FOLLOW_NONE +// mode - usually 0 ? +// options - Bitwise-OR of BGL_* tokens +// +BGLView::BGLView(BRect rect, char *name, + ulong resizingMode, ulong mode, + ulong options) + : BView(rect, name, B_FOLLOW_ALL_SIDES, mode | B_WILL_DRAW | B_FRAME_EVENTS) // | B_FULL_UPDATE_ON_RESIZE) { - mContext = NULL; - mVisual = NULL; - mBuffer = NULL; - mBGLView = NULL; - mBitmap = NULL; - mClearColor[BE_RCOMP] = 0; - mClearColor[BE_GCOMP] = 0; - mClearColor[BE_BCOMP] = 0; - mClearColor[BE_ACOMP] = 0; - mClearIndex = 0; -} + // 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 = 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; -AuxInfo::~AuxInfo() -{ + 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(); + + // examine option flags and create gl_context struct + GLvisual * visual = _mesa_create_visual( rgbFlag, + 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; + + // create core context + GLcontext *ctx = _mesa_create_context(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, + depth > 0 ? GL_TRUE : GL_FALSE, + stencil > 0 ? GL_TRUE: GL_FALSE, + accum > 0 ? GL_TRUE : GL_FALSE, + alphaFlag + ); + + /* Initialize the software rasterizer and helper modules. + */ + _swrast_CreateContext(ctx); + _ac_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(); + } - _mesa_destroy_visual(mVisual); - _mesa_destroy_framebuffer(mBuffer); - _mesa_destroy_context(mContext); } -void AuxInfo::Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b) +BGLView::~BGLView() { - mBGLView = bglView; - mContext = c; - mVisual = v; - mBuffer = b; + // printf("BGLView destructor\n"); + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + delete md; } +void BGLView::LockGL() +{ + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + md->LockGL(); +} -void AuxInfo::MakeCurrent() +void BGLView::UnlockGL() { - UpdateState(mContext); - _mesa_make_current(mContext, mBuffer); + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + md->UnlockGL(); } +void BGLView::SwapBuffers() +{ + SwapBuffers(false); +} -void AuxInfo::SwapBuffers() const +void BGLView::SwapBuffers(bool vSync) { - if (mBitmap) { - mBGLView->DrawBitmap(mBitmap, BPoint(0, 0)); - } + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + md->SwapBuffers(); + + if (vSync) { + BScreen screen(Window()); + screen.WaitForRetrace(); + } } -void AuxInfo::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const +#if 0 +void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height) { - if (mBitmap) { - // Source bitmap and view's bitmap are same size. - // Source and dest rectangle are the same. - // Note (x,y) = (0,0) is the lower-left corner, have to flip Y - BRect srcAndDest; - srcAndDest.left = x; - srcAndDest.right = x + width - 1; - srcAndDest.bottom = mBottom - y; - srcAndDest.top = srcAndDest.bottom - height + 1; - mBGLView->DrawBitmap(mBitmap, srcAndDest, srcAndDest); - } + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + md->CopySubBuffer(x, y, width, height); } +#endif +BView * BGLView::EmbeddedView() +{ + return NULL; +} -void AuxInfo::UpdateState( GLcontext *ctx ) +status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; + if (! dest || ! dest->Bounds().IsValid()) + return B_BAD_VALUE; - assert(aux->mContext == ctx ); + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + return md->CopyPixelsOut(source, dest); +} - ctx->Driver.UpdateState = AuxInfo::UpdateState; - ctx->Driver.SetDrawBuffer = AuxInfo::SetDrawBuffer; - ctx->Driver.SetReadBuffer = AuxInfo::SetReadBuffer; - ctx->Driver.ClearIndex = AuxInfo::ClearIndex; - ctx->Driver.ClearColor = AuxInfo::ClearColor; - ctx->Driver.GetBufferSize = AuxInfo::GetBufferSize; - ctx->Driver.GetString = AuxInfo::GetString; - ctx->Driver.Clear = AuxInfo::Clear; +status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest) +{ + if (! source || ! source->Bounds().IsValid()) + return B_BAD_VALUE; - if (ctx->Color.DrawBuffer == GL_FRONT) { - /* read/write front buffer */ - ctx->Driver.WriteRGBASpan = AuxInfo::WriteRGBASpanFront; - ctx->Driver.WriteRGBSpan = AuxInfo::WriteRGBSpanFront; - ctx->Driver.WriteRGBAPixels = AuxInfo::WriteRGBAPixelsFront; - ctx->Driver.WriteMonoRGBASpan = AuxInfo::WriteMonoRGBASpanFront; - ctx->Driver.WriteMonoRGBAPixels = AuxInfo::WriteMonoRGBAPixelsFront; - ctx->Driver.WriteCI32Span = AuxInfo::WriteCI32SpanFront; - ctx->Driver.WriteCI8Span = AuxInfo::WriteCI8SpanFront; - ctx->Driver.WriteMonoCISpan = AuxInfo::WriteMonoCISpanFront; - ctx->Driver.WriteCI32Pixels = AuxInfo::WriteCI32PixelsFront; - ctx->Driver.WriteMonoCIPixels = AuxInfo::WriteMonoCIPixelsFront; - ctx->Driver.ReadRGBASpan = AuxInfo::ReadRGBASpanFront; - ctx->Driver.ReadRGBAPixels = AuxInfo::ReadRGBAPixelsFront; - ctx->Driver.ReadCI32Span = AuxInfo::ReadCI32SpanFront; - ctx->Driver.ReadCI32Pixels = AuxInfo::ReadCI32PixelsFront; - } - else { - /* read/write back buffer */ - ctx->Driver.WriteRGBASpan = AuxInfo::WriteRGBASpanBack; - ctx->Driver.WriteRGBSpan = AuxInfo::WriteRGBSpanBack; - ctx->Driver.WriteRGBAPixels = AuxInfo::WriteRGBAPixelsBack; - ctx->Driver.WriteMonoRGBASpan = AuxInfo::WriteMonoRGBASpanBack; - ctx->Driver.WriteMonoRGBAPixels = AuxInfo::WriteMonoRGBAPixelsBack; - ctx->Driver.WriteCI32Span = AuxInfo::WriteCI32SpanBack; - ctx->Driver.WriteCI8Span = AuxInfo::WriteCI8SpanBack; - ctx->Driver.WriteMonoCISpan = AuxInfo::WriteMonoCISpanBack; - ctx->Driver.WriteCI32Pixels = AuxInfo::WriteCI32PixelsBack; - ctx->Driver.WriteMonoCIPixels = AuxInfo::WriteMonoCIPixelsBack; - ctx->Driver.ReadRGBASpan = AuxInfo::ReadRGBASpanBack; - ctx->Driver.ReadRGBAPixels = AuxInfo::ReadRGBAPixelsBack; - ctx->Driver.ReadCI32Span = AuxInfo::ReadCI32SpanBack; - ctx->Driver.ReadCI32Pixels = AuxInfo::ReadCI32PixelsBack; - } + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + return md->CopyPixelsIn(source, dest); } -void AuxInfo::ClearIndex(GLcontext *ctx, GLuint index) +void BGLView::ErrorCallback(unsigned long errorCode) // Mesa's GLenum is not ulong but uint! { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - aux->mClearIndex = index; + char msg[32]; + sprintf(msg, "GL: Error code $%04lx.", errorCode); + // debugger(msg); + fprintf(stderr, "%s\n", msg); + return; } - -void AuxInfo::ClearColor(GLcontext *ctx, GLubyte r, GLubyte g, - GLubyte b, GLubyte a) +void BGLView::Draw(BRect updateRect) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - aux->mClearColor[BE_RCOMP] = r; - aux->mClearColor[BE_GCOMP] = g; - aux->mClearColor[BE_BCOMP] = b; - aux->mClearColor[BE_ACOMP] = a; - assert(aux->mBGLView); + // printf("BGLView::Draw()\n"); + MesaDriver * md = (MesaDriver *) m_gc; + assert(md); + md->Draw(updateRect); } - -GLbitfield AuxInfo::Clear(GLcontext *ctx, GLbitfield mask, - GLboolean all, GLint x, GLint y, - GLint width, GLint height) +void BGLView::AttachedToWindow() { - if (mask & DD_FRONT_LEFT_BIT) - ClearFront(ctx, all, x, y, width, height); - if (mask & DD_BACK_LEFT_BIT) - ClearBack(ctx, all, x, y, width, height); - return mask & ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT); -} + BView::AttachedToWindow(); + // don't paint window background white when resized + SetViewColor(B_TRANSPARENT_32_BIT); +} -void AuxInfo::ClearFront(GLcontext *ctx, - GLboolean all, GLint x, GLint y, - GLint width, GLint height) +void BGLView::AllAttached() { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - - bglview->SetHighColor(aux->mClearColor[BE_RCOMP], - aux->mClearColor[BE_GCOMP], - aux->mClearColor[BE_BCOMP], - aux->mClearColor[BE_ACOMP]); - bglview->SetLowColor(aux->mClearColor[BE_RCOMP], - aux->mClearColor[BE_GCOMP], - aux->mClearColor[BE_BCOMP], - aux->mClearColor[BE_ACOMP]); - if (all) { - BRect b = bglview->Bounds(); - bglview->FillRect(b); - } - else { - // XXX untested - BRect b; - b.left = x; - b.right = x + width; - b.bottom = aux->mHeight - y - 1; - b.top = b.bottom - height; - bglview->FillRect(b); - } + BView::AllAttached(); +// printf("BGLView AllAttached\n"); +} - // restore drawing color -#if 0 - bglview->SetHighColor(aux->mColor[BE_RCOMP], - aux->mColor[BE_GCOMP], - aux->mColor[BE_BCOMP], - aux->mColor[BE_ACOMP]); - bglview->SetLowColor(aux->mColor[BE_RCOMP], - aux->mColor[BE_GCOMP], - aux->mColor[BE_BCOMP], - aux->mColor[BE_ACOMP]); -#endif +void BGLView::DetachedFromWindow() +{ + BView::DetachedFromWindow(); } +void BGLView::AllDetached() +{ + BView::AllDetached(); +// printf("BGLView AllDetached"); +} -void AuxInfo::ClearBack(GLcontext *ctx, - GLboolean all, GLint x, GLint y, - GLint width, GLint height) +void BGLView::FrameResized(float width, float height) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - GLuint *start = (GLuint *) bitmap->Bits(); - const GLuint *clearPixelPtr = (const GLuint *) aux->mClearColor; - const GLuint clearPixel = *clearPixelPtr; + return BView::FrameResized(width, height); +} - if (all) { - const int numPixels = aux->mWidth * aux->mHeight; - if (clearPixel == 0) { - memset(start, 0, numPixels * 4); - } - else { - for (int i = 0; i < numPixels; i++) { - start[i] = clearPixel; - } - } - } - else { - // XXX untested - start += y * aux->mWidth + x; - for (int i = 0; i < height; i++) { - for (int j = 0; j < width; j++) { - start[j] = clearPixel; - } - start += aux->mWidth; - } - } +status_t BGLView::Perform(perform_code d, void *arg) +{ + return BView::Perform(d, arg); } -GLboolean AuxInfo::SetDrawBuffer(GLcontext *ctx, GLenum buffer) +status_t BGLView::Archive(BMessage *data, bool deep) const { - if (buffer == GL_FRONT_LEFT) - return GL_TRUE; - else if (buffer == GL_BACK_LEFT) - return GL_TRUE; - else - return GL_FALSE; + return BView::Archive(data, deep); } -void AuxInfo::SetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, - GLenum buffer) +void BGLView::MessageReceived(BMessage *msg) { - /* XXX to do */ + BView::MessageReceived(msg); } -void AuxInfo::GetBufferSize(GLcontext *ctx, GLuint *width, - GLuint *height) +void BGLView::SetResizingMode(uint32 mode) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - BRect b = bglview->Bounds(); - *width = (GLuint) (b.right - b.left + 1); - *height = (GLuint) (b.bottom - b.top + 1); - aux->mBottom = (GLint) b.bottom; + BView::SetResizingMode(mode); +} - if (ctx->Visual->DBflag) { - if (*width != aux->mWidth || *height != aux->mHeight) { - // allocate new size of back buffer bitmap - if (aux->mBitmap) - delete aux->mBitmap; - BRect rect(0.0, 0.0, *width - 1, *height - 1); - aux->mBitmap = new BBitmap(rect, B_RGBA32); - } - } - else - { - aux->mBitmap = NULL; - } +void BGLView::Show() +{ + BView::Show(); +} - aux->mWidth = *width; - aux->mHeight = *height; +void BGLView::Hide() +{ + BView::Hide(); } +BHandler *BGLView::ResolveSpecifier(BMessage *msg, int32 index, + BMessage *specifier, int32 form, + const char *property) +{ + return BView::ResolveSpecifier(msg, index, specifier, form, property); +} -const GLubyte *AuxInfo::GetString(GLcontext *ctx, GLenum name) +status_t BGLView::GetSupportedSuites(BMessage *data) { - switch (name) { - case GL_RENDERER: - return (const GLubyte *) "Mesa BeOS"; - default: - // Let core library handle all other cases - return NULL; - } + return BView::GetSupportedSuites(data); } +void BGLView::DirectConnected( direct_buffer_info *info ) +{ +#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 +} -// 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) +void BGLView::EnableDirectMode( bool enabled ) { - // XXX There's got to be a better way! - BPoint p(x, y), q(x+1, y); - bglview->StrokeLine(p, q); + // TODO } -void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n, - GLint x, GLint y, - CONST GLubyte rgba[][4], - const GLubyte mask[]) +//---- virtual reserved methods ---------- + +void BGLView::_ReservedGLView1() {} +void BGLView::_ReservedGLView2() {} +void BGLView::_ReservedGLView3() {} +void BGLView::_ReservedGLView4() {} +void BGLView::_ReservedGLView5() {} +void BGLView::_ReservedGLView6() {} +void BGLView::_ReservedGLView7() {} +void BGLView::_ReservedGLView8() {} + +#if 0 +// Not implemented!!! + +BGLView::BGLView(const BGLView &v) + : BView(v) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - int flippedY = aux->mBottom - y; - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], rgba[i][3]); - Plot(bglview, x++, flippedY); - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], rgba[i][3]); - Plot(bglview, x++, flippedY); - } - } + // XXX not sure how this should work + printf("Warning BGLView::copy constructor not implemented\n"); } -void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n, - GLint x, GLint y, - CONST GLubyte rgba[][3], - const GLubyte mask[]) +BGLView &BGLView::operator=(const BGLView &v) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - int flippedY = aux->mBottom - y; - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); - Plot(bglview, x++, flippedY); - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); - Plot(bglview, x++, flippedY); - } - } + printf("Warning BGLView::operator= not implemented\n"); + return *this; } +#endif -void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n, - GLint x, GLint y, - const GLchan color[4], - const GLubyte mask[]) +void BGLView::dither_front() { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - int flippedY = aux->mBottom - y; - bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]); - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - Plot(bglview, x++, flippedY); - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - Plot(bglview, x++, flippedY); - } - } + // no-op } -void AuxInfo::WriteRGBAPixelsFront(const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - CONST GLubyte rgba[][4], - const GLubyte mask[] ) +bool BGLView::confirm_dither() { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); - Plot(bglview, x[i], aux->mBottom - y[i]); - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); - Plot(bglview, x[i], aux->mBottom - y[i]); - } - } + // no-op + return false; } - -void AuxInfo::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n, - const GLint x[], const GLint y[], - const GLchan color[4], - const GLubyte mask[]) +void BGLView::draw(BRect r) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BGLView *bglview = aux->mBGLView; - assert(bglview); - // plot points using current color - bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]); - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - Plot(bglview, x[i], aux->mBottom - y[i]); - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - Plot(bglview, x[i], aux->mBottom - y[i]); - } - } + // XXX no-op ??? } - -void AuxInfo::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y, - const GLuint index[], const GLubyte mask[] ) +/* Direct Window stuff */ +void BGLView::drawScanline( int x1, int x2, int y, void *data ) { - // XXX to do + // no-op } -void AuxInfo::WriteCI8SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y, - const GLubyte index[], const GLubyte mask[] ) +void BGLView::scanlineHandler(struct rasStateRec *state, + GLint x1, GLint x2) { - // XXX to do + // no-op } -void AuxInfo::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n, - GLint x, GLint y, - GLuint colorIndex, const GLubyte mask[] ) +void BGLView::lock_draw() { - // XXX to do + // no-op } - -void AuxInfo::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n, - const GLint x[], const GLint y[], - const GLuint index[], const GLubyte mask[] ) +void BGLView::unlock_draw() { - // XXX to do + // no-op } -void AuxInfo::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n, - const GLint x[], const GLint y[], - GLuint colorIndex, const GLubyte mask[] ) +bool BGLView::validateView() { - // XXX to do + // no-op + return true; } +// #pragma mark - -void AuxInfo::ReadCI32SpanFront( const GLcontext *ctx, - GLuint n, GLint x, GLint y, GLuint index[] ) +MesaDriver::MesaDriver() { - // XXX to do -} + m_glcontext = NULL; + m_glvisual = NULL; + m_glframebuffer = NULL; + m_bglview = NULL; + m_bitmap = NULL; + m_clear_color[BE_RCOMP] = 0; + m_clear_color[BE_GCOMP] = 0; + m_clear_color[BE_BCOMP] = 0; + m_clear_color[BE_ACOMP] = 0; -void AuxInfo::ReadRGBASpanFront( const GLcontext *ctx, GLuint n, - GLint x, GLint y, GLubyte rgba[][4] ) -{ - // XXX to do + m_clear_index = 0; } -void AuxInfo::ReadCI32PixelsFront( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLuint indx[], const GLubyte mask[] ) +MesaDriver::~MesaDriver() { - // XXX to do + _mesa_destroy_visual(m_glvisual); + _mesa_destroy_framebuffer(m_glframebuffer); + _mesa_destroy_context(m_glcontext); + + delete m_bitmap; } -void AuxInfo::ReadRGBAPixelsFront( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLubyte rgba[][4], const GLubyte mask[] ) +void MesaDriver::Init(BGLView * bglview, GLcontext * ctx, GLvisual * visual, GLframebuffer * framebuffer) { - // XXX to do -} + m_bglview = bglview; + m_glcontext = ctx; + m_glvisual = visual; + m_glframebuffer = framebuffer; + MesaDriver * md = (MesaDriver *) ctx->DriverCtx; + struct swrast_device_driver * swdd = _swrast_GetDeviceDriverReference( ctx ); + TNLcontext * tnl = TNL_CONTEXT(ctx); + assert(md->m_glcontext == ctx ); + assert(tnl); + assert(swdd); - -void AuxInfo::WriteRGBASpanBack(const GLcontext *ctx, GLuint n, - GLint x, GLint y, - CONST GLubyte rgba[][4], - const GLubyte mask[]) -{ - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - int row = aux->mBottom - y; - GLubyte *pixel = (GLubyte *) bitmap->Bits() + (row * aux->mWidth + x) * 4; - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - pixel[BE_RCOMP] = rgba[i][RCOMP]; - pixel[BE_GCOMP] = rgba[i][GCOMP]; - pixel[BE_BCOMP] = rgba[i][BCOMP]; - pixel[BE_ACOMP] = rgba[i][ACOMP]; - } - pixel += 4; - } - } - else { - for (GLuint i = 0; i < n; i++) { - pixel[BE_RCOMP] = rgba[i][RCOMP]; - pixel[BE_GCOMP] = rgba[i][GCOMP]; - pixel[BE_BCOMP] = rgba[i][BCOMP]; - pixel[BE_ACOMP] = rgba[i][ACOMP]; - pixel += 4; - } - } + // Use default TCL pipeline + tnl->Driver.RunPipeline = _tnl_run_pipeline; + + swdd->SetBuffer = this->SetBuffer; } -void AuxInfo::WriteRGBSpanBack(const GLcontext *ctx, GLuint n, - GLint x, GLint y, - CONST GLubyte rgb[][3], - const GLubyte mask[]) +void MesaDriver::LockGL() { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - int row = aux->mBottom - y; - GLubyte *pixel = (GLubyte *) bitmap->Bits() + (row * aux->mWidth + x) * 4; - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - pixel[BE_RCOMP] = rgb[i][RCOMP]; - pixel[BE_GCOMP] = rgb[i][GCOMP]; - pixel[BE_BCOMP] = rgb[i][BCOMP]; - pixel[BE_ACOMP] = 255; - } - pixel += 4; - } - } - else { - for (GLuint i = 0; i < n; i++) { - pixel[BE_RCOMP] = rgb[i][RCOMP]; - pixel[BE_GCOMP] = rgb[i][GCOMP]; - pixel[BE_BCOMP] = rgb[i][BCOMP]; - pixel[BE_ACOMP] = 255; - pixel += 4; - } - } + m_bglview->LockLooper(); + + UpdateState(m_glcontext, 0); + _mesa_make_current(m_glcontext, m_glframebuffer); } -void AuxInfo::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n, - GLint x, GLint y, - const GLchan color[4], const GLubyte mask[]) +void MesaDriver::UnlockGL() { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - int row = aux->mBottom - y; - GLuint *pixelPtr = (GLuint *) bitmap->Bits() + row * aux->mWidth + x; - GLuint pixel; - GLubyte *mColor= (GLubyte *) &pixel; - mColor[BE_RCOMP] = color[RCOMP]; - mColor[BE_GCOMP] = color[GCOMP]; - mColor[BE_BCOMP] = color[BCOMP]; - mColor[BE_ACOMP] = color[ACOMP]; - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) - *pixelPtr = pixel; - pixelPtr++; - } - } - else { - for (GLuint i = 0; i < n; i++) { - *pixelPtr++ = pixel; - } - } + if (m_bglview->Looper()->IsLocked()) + m_bglview->UnlockLooper(); + // Could call _mesa_make_current(NULL, NULL) but it would just + // hinder performance } -void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - CONST GLubyte rgba[][4], - const GLubyte mask[] ) +void MesaDriver::SwapBuffers() const { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - GLubyte *pixel = (GLubyte *) bitmap->Bits() - + (aux->mBottom - y[i]) * bitmap->BytesPerRow() + x[i] * 4; - pixel[BE_RCOMP] = rgba[i][RCOMP]; - pixel[BE_GCOMP] = rgba[i][GCOMP]; - pixel[BE_BCOMP] = rgba[i][BCOMP]; - pixel[BE_ACOMP] = rgba[i][ACOMP]; - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - GLubyte *pixel = (GLubyte *) bitmap->Bits() - + (aux->mBottom - y[i]) * bitmap->BytesPerRow() + x[i] * 4; - pixel[BE_RCOMP] = rgba[i][RCOMP]; - pixel[BE_GCOMP] = rgba[i][GCOMP]; - pixel[BE_BCOMP] = rgba[i][BCOMP]; - pixel[BE_ACOMP] = rgba[i][ACOMP]; - } - } + _mesa_notifySwapBuffers(m_glcontext); + + if (m_bitmap) { + m_bglview->LockLooper(); + m_bglview->DrawBitmap(m_bitmap); + m_bglview->UnlockLooper(); + }; } -void AuxInfo::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n, - const GLint x[], const GLint y[], - const GLchan color[4], - const GLubyte mask[]) +void MesaDriver::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - BBitmap *bitmap = aux->mBitmap; - GLuint pixel; - GLubyte *mColor= (GLubyte *) &pixel; - mColor[BE_RCOMP] = color[RCOMP]; - mColor[BE_GCOMP] = color[GCOMP]; - mColor[BE_BCOMP] = color[BCOMP]; - mColor[BE_ACOMP] = color[ACOMP]; - assert(bitmap); - if (mask) { - for (GLuint i = 0; i < n; i++) { - if (mask[i]) { - GLuint *pixelPtr = (GLuint *) bitmap->Bits() - + (aux->mBottom - y[i]) * aux->mWidth + x[i]; - *pixelPtr = pixel; - } - } - } - else { - for (GLuint i = 0; i < n; i++) { - GLuint *pixelPtr = (GLuint *) bitmap->Bits() - + (aux->mBottom - y[i]) * aux->mWidth + x[i]; - *pixelPtr = pixel; - } + if (m_bitmap) { + // Source bitmap and view's bitmap are same size. + // Source and dest rectangle are the same. + // Note (x,y) = (0,0) is the lower-left corner, have to flip Y + BRect srcAndDest; + srcAndDest.left = x; + srcAndDest.right = x + width - 1; + srcAndDest.bottom = m_bottom - y; + srcAndDest.top = srcAndDest.bottom - height + 1; + m_bglview->DrawBitmap(m_bitmap, srcAndDest, srcAndDest); } } - -void AuxInfo::WriteCI32SpanBack( const GLcontext *ctx, GLuint n, - GLint x, GLint y, - const GLuint index[], const GLubyte mask[] ) +status_t MesaDriver::CopyPixelsOut(BPoint location, BBitmap *bitmap) { - // XXX to do + 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; } -void AuxInfo::WriteCI8SpanBack( const GLcontext *ctx, GLuint n, - GLint x, GLint y, - const GLubyte index[], const GLubyte mask[] ) +status_t MesaDriver::CopyPixelsIn(BBitmap *bitmap, BPoint location) { - // XXX to do + 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 AuxInfo::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n, - GLint x, GLint y, - GLuint colorIndex, const GLubyte mask[] ) + +void MesaDriver::Draw(BRect updateRect) const { - // XXX to do + if (m_bitmap) + m_bglview->DrawBitmap(m_bitmap, updateRect, updateRect); } -void AuxInfo::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n, - const GLint x[], const GLint y[], - const GLuint index[], const GLubyte mask[] ) +void MesaDriver::Error(GLcontext *ctx) { - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + if (md && md->m_bglview) + md->m_bglview->ErrorCallback((unsigned long) ctx->ErrorValue); } -void AuxInfo::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n, - const GLint x[], const GLint y[], - GLuint colorIndex, const GLubyte mask[] ) +void MesaDriver::UpdateState( GLcontext *ctx, GLuint new_state ) { - // XXX to do -} + struct swrast_device_driver * swdd = _swrast_GetDeviceDriverReference( ctx ); + _swrast_InvalidateState( ctx, new_state ); + _swsetup_InvalidateState( ctx, new_state ); + _ac_InvalidateState( ctx, new_state ); + _tnl_InvalidateState( ctx, new_state ); -void AuxInfo::ReadCI32SpanBack( const GLcontext *ctx, - GLuint n, GLint x, GLint y, GLuint index[] ) -{ - // XXX to do + if (ctx->Color.DrawBuffer[0] == GL_FRONT) { + /* read/write front buffer */ + swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanFront; + swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanFront; + swdd->WriteRGBAPixels = MesaDriver::WriteRGBAPixelsFront; + swdd->WriteMonoRGBASpan = MesaDriver::WriteMonoRGBASpanFront; + swdd->WriteMonoRGBAPixels = MesaDriver::WriteMonoRGBAPixelsFront; + swdd->WriteCI32Span = MesaDriver::WriteCI32SpanFront; + swdd->WriteCI8Span = MesaDriver::WriteCI8SpanFront; + swdd->WriteMonoCISpan = MesaDriver::WriteMonoCISpanFront; + swdd->WriteCI32Pixels = MesaDriver::WriteCI32PixelsFront; + swdd->WriteMonoCIPixels = MesaDriver::WriteMonoCIPixelsFront; + swdd->ReadRGBASpan = MesaDriver::ReadRGBASpanFront; + swdd->ReadRGBAPixels = MesaDriver::ReadRGBAPixelsFront; + swdd->ReadCI32Span = MesaDriver::ReadCI32SpanFront; + swdd->ReadCI32Pixels = MesaDriver::ReadCI32PixelsFront; + } + else { + /* read/write back buffer */ + swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanBack; + swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanBack; + swdd->WriteRGBAPixels = MesaDriver::WriteRGBAPixelsBack; + swdd->WriteMonoRGBASpan = MesaDriver::WriteMonoRGBASpanBack; + swdd->WriteMonoRGBAPixels = MesaDriver::WriteMonoRGBAPixelsBack; + swdd->WriteCI32Span = MesaDriver::WriteCI32SpanBack; + swdd->WriteCI8Span = MesaDriver::WriteCI8SpanBack; + swdd->WriteMonoCISpan = MesaDriver::WriteMonoCISpanBack; + swdd->WriteCI32Pixels = MesaDriver::WriteCI32PixelsBack; + swdd->WriteMonoCIPixels = MesaDriver::WriteMonoCIPixelsBack; + swdd->ReadRGBASpan = MesaDriver::ReadRGBASpanBack; + swdd->ReadRGBAPixels = MesaDriver::ReadRGBAPixelsBack; + swdd->ReadCI32Span = MesaDriver::ReadCI32SpanBack; + swdd->ReadCI32Pixels = MesaDriver::ReadCI32PixelsBack; + } } -void AuxInfo::ReadRGBASpanBack( const GLcontext *ctx, GLuint n, - GLint x, GLint y, GLubyte rgba[][4] ) +void MesaDriver::ClearIndex(GLcontext *ctx, GLuint index) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - const BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - int row = aux->mBottom - y; - const GLubyte *pixel = (GLubyte *) bitmap->Bits() - + row * bitmap->BytesPerRow() + x * 4; - for (GLuint i = 0; i < n; i++) { - rgba[i][RCOMP] = pixel[BE_RCOMP]; - rgba[i][GCOMP] = pixel[BE_GCOMP]; - rgba[i][BCOMP] = pixel[BE_BCOMP]; - rgba[i][ACOMP] = pixel[BE_ACOMP]; - pixel += 4; - } + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + md->m_clear_index = index; } -void AuxInfo::ReadCI32PixelsBack( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLuint indx[], const GLubyte mask[] ) +void MesaDriver::ClearColor(GLcontext *ctx, const GLfloat color[4]) { - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + 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 AuxInfo::ReadRGBAPixelsBack( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLubyte rgba[][4], const GLubyte mask[] ) +void MesaDriver::Clear(GLcontext *ctx, GLbitfield mask, + GLboolean all, GLint x, GLint y, + GLint width, GLint height) { - AuxInfo *aux = (AuxInfo *) ctx->DriverCtx; - const BBitmap *bitmap = aux->mBitmap; - assert(bitmap); - for (GLuint i = 0; i < n; i++) { - if (y[i] < aux->mHeight) { - const GLubyte *pixel = (const GLubyte *) bitmap->Bits() - + ((aux->mBottom - y[i]) * aux->mWidth + x[i]) * 4; - rgba[i][RCOMP] = pixel[BE_RCOMP]; - rgba[i][GCOMP] = pixel[BE_GCOMP]; - rgba[i][BCOMP] = pixel[BE_BCOMP]; - rgba[i][ACOMP] = pixel[BE_ACOMP]; - } - } -} + if (mask & DD_FRONT_LEFT_BIT) + ClearFront(ctx, all, x, y, width, height); + if (mask & DD_BACK_LEFT_BIT) + ClearBack(ctx, all, x, y, width, height); + mask &= ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT); + if (mask) + _swrast_Clear( ctx, mask, all, x, y, width, height ); + return; +} -//------------------------------------------------------------------ -// Public interface methods -//------------------------------------------------------------------ - - -// -// Input: rect - initial rectangle -// name - window name -// resizingMode - example: B_FOLLOW_NONE -// mode - usually 0 ? -// options - Bitwise-OR of BGL_* tokens -// -BGLView::BGLView(BRect rect, char *name, - ulong resizingMode, ulong mode, - ulong options) - :BView(rect, name, resizingMode, mode) +void MesaDriver::ClearFront(GLcontext *ctx, + GLboolean all, GLint x, GLint y, + GLint width, GLint height) { - const GLboolean rgbFlag = (options & BGL_RGB) == BGL_RGB; - 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; + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); - if (!rgbFlag) { - fprintf(stderr, "Mesa Warning: color index mode not supported\n"); + bglview->SetHighColor(md->m_clear_color[BE_RCOMP], + md->m_clear_color[BE_GCOMP], + md->m_clear_color[BE_BCOMP], + md->m_clear_color[BE_ACOMP]); + bglview->SetLowColor(md->m_clear_color[BE_RCOMP], + md->m_clear_color[BE_GCOMP], + md->m_clear_color[BE_BCOMP], + md->m_clear_color[BE_ACOMP]); + if (all) { + BRect b = bglview->Bounds(); + bglview->FillRect(b); + } + else { + // XXX untested + BRect b; + b.left = x; + b.right = x + width; + b.bottom = md->m_height - y - 1; + b.top = b.bottom - height; + bglview->FillRect(b); } - // Allocate auxiliary data object - AuxInfo *aux = new AuxInfo; - - // examine option flags and create gl_context struct - GLvisual *visual = _mesa__create_visual( rgbFlag, - dblFlag, - stereoFlag, - red, green, blue, alpha, - index, - depth, - stencil, - accum, accum, accum, accum, - 1 - ); - - // create core framebuffer - GLframebuffer *buffer = _mesa_create_framebuffer(visual, - depth > 0 ? GL_TRUE : GL_FALSE, - stencil > 0 ? GL_TRUE: GL_FALSE, - accum > 0 ? GL_TRUE : GL_FALSE, - alphaFlag - ); + // restore drawing color +#if 0 + bglview->SetHighColor(md->mColor[BE_RCOMP], + md->mColor[BE_GCOMP], + md->mColor[BE_BCOMP], + md->mColor[BE_ACOMP]); + bglview->SetLowColor(md->mColor[BE_RCOMP], + md->mColor[BE_GCOMP], + md->mColor[BE_BCOMP], + md->mColor[BE_ACOMP]); +#endif +} - // create core context - const GLboolean direct = GL_TRUE; - GLcontext *ctx = _mesa_create_context( visual, NULL, aux, direct ); - aux->Init(this, ctx, visual, buffer ); +void MesaDriver::ClearBack(GLcontext *ctx, + GLboolean all, GLint x, GLint y, + GLint width, GLint height) +{ + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); + BBitmap *bitmap = md->m_bitmap; + assert(bitmap); + GLuint *start = (GLuint *) bitmap->Bits(); + const GLuint *clearPixelPtr = (const GLuint *) md->m_clear_color; + const GLuint clearPixel = B_LENDIAN_TO_HOST_INT32(*clearPixelPtr); - // Hook aux data into BGLView object - m_gc = aux; + if (all) { + const int numPixels = md->m_width * md->m_height; + if (clearPixel == 0) { + memset(start, 0, numPixels * 4); + } + else { + for (int i = 0; i < numPixels; i++) { + start[i] = clearPixel; + } + } + } + else { + // XXX untested + start += y * md->m_width + x; + for (int i = 0; i < height; i++) { + for (int j = 0; j < width; j++) { + start[j] = clearPixel; + } + start += md->m_width; + } + } } -BGLView::~BGLView() +void MesaDriver::SetBuffer(GLcontext *ctx, GLframebuffer *buffer, + GLenum mode) { - printf("BGLView destructor\n"); - AuxInfo *aux = (AuxInfo *) m_gc; - assert(aux); - delete aux; + /* TODO */ + (void) ctx; + (void) buffer; + (void) mode; } -void BGLView::LockGL() +void MesaDriver::GetBufferSize(GLframebuffer * framebuffer, GLuint *width, + GLuint *height) { - AuxInfo *aux = (AuxInfo *) m_gc; - assert(aux); - aux->MakeCurrent(); -} + GET_CURRENT_CONTEXT(ctx); + if (!ctx) + return; -void BGLView::UnlockGL() -{ - AuxInfo *aux = (AuxInfo *) m_gc; - assert(aux); - // Could call _mesa_make_current(NULL, NULL) but it would just - // hinder performance -} + MesaDriver * md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); -void BGLView::SwapBuffers() -{ - AuxInfo *aux = (AuxInfo *) m_gc; - assert(aux); - aux->SwapBuffers(); -} + BRect b = bglview->Bounds(); + *width = (GLuint) b.IntegerWidth() + 1; // (b.right - b.left + 1); + *height = (GLuint) b.IntegerHeight() + 1; // (b.bottom - b.top + 1); + md->m_bottom = (GLint) b.bottom; + if (ctx->Visual.doubleBufferMode) { + if (*width != md->m_width || *height != md->m_height) { + // allocate new size of back buffer bitmap + if (md->m_bitmap) + delete md->m_bitmap; + BRect rect(0.0, 0.0, *width - 1, *height - 1); + md->m_bitmap = new BBitmap(rect, B_RGBA32); + } + } + else + { + md->m_bitmap = NULL; + } -void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height) -{ - AuxInfo *aux = (AuxInfo *) m_gc; - assert(aux); - aux->CopySubBuffer(x, y, width, height); + md->m_width = *width; + md->m_height = *height; } -BView *BGLView::EmbeddedView() +const GLubyte *MesaDriver::GetString(GLcontext *ctx, GLenum name) { - // XXX to do - + switch (name) { + case GL_RENDERER: + return (const GLubyte *) "Mesa " MESA_VERSION_STRING " powered BGLView (software)"; + default: + // Let core library handle all other cases + return NULL; + } } -status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest) + +// Plot a pixel. (0,0) is upper-left corner +// This is only used when drawing to the front buffer. +inline void Plot(BGLView *bglview, int x, int y) { - // XXX to do + // XXX There's got to be a better way! + BPoint p(x, y), q(x+1, y); + bglview->StrokeLine(p, q); } -status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest) +void MesaDriver::WriteRGBASpanFront(const GLcontext *ctx, GLuint n, + GLint x, GLint y, + CONST GLubyte rgba[][4], + const GLubyte mask[]) { - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); + int flippedY = md->m_bottom - y; + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], rgba[i][3]); + Plot(bglview, x++, flippedY); + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], rgba[i][3]); + Plot(bglview, x++, flippedY); + } + } } -void BGLView::ErrorCallback(GLenum errorCode) +void MesaDriver::WriteRGBSpanFront(const GLcontext *ctx, GLuint n, + GLint x, GLint y, + CONST GLubyte rgba[][3], + const GLubyte mask[]) { - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); + int flippedY = md->m_bottom - y; + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); + Plot(bglview, x++, flippedY); + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); + Plot(bglview, x++, flippedY); + } + } } -void BGLView::Draw(BRect updateRect) +void MesaDriver::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n, + GLint x, GLint y, + const GLchan color[4], + const GLubyte mask[]) { -// printf("BGLView draw\n"); - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); + int flippedY = md->m_bottom - y; + bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]); + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + Plot(bglview, x++, flippedY); + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + Plot(bglview, x++, flippedY); + } + } } -void BGLView::AttachedToWindow() +void MesaDriver::WriteRGBAPixelsFront(const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + CONST GLubyte rgba[][4], + const GLubyte mask[] ) { - BView::AttachedToWindow(); - - // don't paint window background white when resized - SetViewColor(B_TRANSPARENT_32_BIT); + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); + Plot(bglview, x[i], md->m_bottom - y[i]); + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]); + Plot(bglview, x[i], md->m_bottom - y[i]); + } + } } -void BGLView::AllAttached() -{ - BView::AllAttached(); -// printf("BGLView AllAttached\n"); -} -void BGLView::DetachedFromWindow() +void MesaDriver::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + const GLchan color[4], + const GLubyte mask[]) { - BView::DetachedFromWindow(); + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BGLView *bglview = md->m_bglview; + assert(bglview); + // plot points using current color + bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]); + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + Plot(bglview, x[i], md->m_bottom - y[i]); + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + Plot(bglview, x[i], md->m_bottom - y[i]); + } + } } -void BGLView::AllDetached() + +void MesaDriver::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y, + const GLuint index[], const GLubyte mask[] ) { - BView::AllDetached(); -// printf("BGLView AllDetached"); + printf("WriteCI32SpanFront() not implemented yet!\n"); + // TODO } -void BGLView::FrameResized(float width, float height) +void MesaDriver::WriteCI8SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y, + const GLubyte index[], const GLubyte mask[] ) { - return BView::FrameResized(width, height); + printf("WriteCI8SpanFront() not implemented yet!\n"); + // TODO } -status_t BGLView::Perform(perform_code d, void *arg) +void MesaDriver::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n, + GLint x, GLint y, + GLuint colorIndex, const GLubyte mask[] ) { - return BView::Perform(d, arg); + printf("WriteMonoCISpanFront() not implemented yet!\n"); + // TODO } -status_t BGLView::Archive(BMessage *data, bool deep) const +void MesaDriver::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + const GLuint index[], const GLubyte mask[] ) { - return BView::Archive(data, deep); + printf("WriteCI32PixelsFront() not implemented yet!\n"); + // TODO } -void BGLView::MessageReceived(BMessage *msg) +void MesaDriver::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + GLuint colorIndex, const GLubyte mask[] ) { - BView::MessageReceived(msg); + printf("WriteMonoCIPixelsFront() not implemented yet!\n"); + // TODO } -void BGLView::SetResizingMode(uint32 mode) + +void MesaDriver::ReadCI32SpanFront( const GLcontext *ctx, + GLuint n, GLint x, GLint y, GLuint index[] ) { - BView::SetResizingMode(mode); + printf("ReadCI32SpanFront() not implemented yet!\n"); + // TODO } -void BGLView::Show() + +void MesaDriver::ReadRGBASpanFront( const GLcontext *ctx, GLuint n, + GLint x, GLint y, GLubyte rgba[][4] ) { -// printf("BGLView Show\n"); - BView::Show(); + printf("ReadRGBASpanFront() not implemented yet!\n"); + // TODO } -void BGLView::Hide() + +void MesaDriver::ReadCI32PixelsFront( const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + GLuint indx[], const GLubyte mask[] ) { -// printf("BGLView Hide\n"); - BView::Hide(); + printf("ReadCI32PixelsFront() not implemented yet!\n"); + // TODO } -BHandler *BGLView::ResolveSpecifier(BMessage *msg, int32 index, - BMessage *specifier, int32 form, - const char *property) + +void MesaDriver::ReadRGBAPixelsFront( const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + GLubyte rgba[][4], const GLubyte mask[] ) { - return BView::ResolveSpecifier(msg, index, specifier, form, property); + printf("ReadRGBAPixelsFront() not implemented yet!\n"); + // TODO } -status_t BGLView::GetSupportedSuites(BMessage *data) + + + +void MesaDriver::WriteRGBASpanBack(const GLcontext *ctx, GLuint n, + GLint x, GLint y, + CONST GLubyte rgba[][4], + const GLubyte mask[]) { - return BView::GetSupportedSuites(data); + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BBitmap *bitmap = md->m_bitmap; + + assert(bitmap); + + int row = md->m_bottom - y; + uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4; + uint32 * pixel = (uint32 *) ptr; + + if (mask) { + while(n--) { + if (*mask++) + *pixel = PACK_B_RGBA32(rgba[0]); + pixel++; + rgba++; + }; + } else { + while(n--) { + *pixel++ = PACK_B_RGBA32(rgba[0]); + rgba++; + }; + }; + } + + +void MesaDriver::WriteRGBSpanBack(const GLcontext *ctx, GLuint n, + GLint x, GLint y, + CONST GLubyte rgb[][3], + const GLubyte mask[]) +{ + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BBitmap *bitmap = md->m_bitmap; + + assert(bitmap); + + int row = md->m_bottom - y; + uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4; + uint32 * pixel = (uint32 *) ptr; + + if (mask) { + while(n--) { + if (*mask++) + *pixel = PACK_B_RGB32(rgb[0]); + pixel++; + rgb++; + }; + } else { + while(n--) { + *pixel++ = PACK_B_RGB32(rgb[0]); + rgb++; + }; + }; } -void BGLView::DirectConnected( direct_buffer_info *info ) + + + +void MesaDriver::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n, + GLint x, GLint y, + const GLchan color[4], const GLubyte mask[]) { - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BBitmap *bitmap = md->m_bitmap; + + assert(bitmap); + + int row = md->m_bottom - y; + uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4; + uint32 * pixel = (uint32 *) ptr; + uint32 pixel_color = PACK_B_RGBA32(color); + + if (mask) { + while(n--) { + if (*mask++) + *pixel = pixel_color; + pixel++; + }; + } else { + while(n--) { + *pixel++ = pixel_color; + }; + }; } -void BGLView::EnableDirectMode( bool enabled ) + +void MesaDriver::WriteRGBAPixelsBack(const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + CONST GLubyte rgba[][4], + const GLubyte mask[] ) { - // XXX to do + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + BBitmap *bitmap = md->m_bitmap; + + assert(bitmap); +#if 0 + while(n--) { + if (*mask++) { + int row = md->m_bottom - *y; + uint8 * pixel = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + *x * 4; + *((uint32 *) pixel) = PACK_B_RGBA32(rgba[0]); + }; + x++; + y++; + rgba++; + }; +#else + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + GLubyte *pixel = (GLubyte *) bitmap->Bits() + + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4; + pixel[BE_RCOMP] = rgba[i][RCOMP]; + pixel[BE_GCOMP] = rgba[i][GCOMP]; + pixel[BE_BCOMP] = rgba[i][BCOMP]; + pixel[BE_ACOMP] = rgba[i][ACOMP]; + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + GLubyte *pixel = (GLubyte *) bitmap->Bits() + + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4; + pixel[BE_RCOMP] = rgba[i][RCOMP]; + pixel[BE_GCOMP] = rgba[i][GCOMP]; + pixel[BE_BCOMP] = rgba[i][BCOMP]; + pixel[BE_ACOMP] = rgba[i][ACOMP]; + } + } +#endif } +void MesaDriver::WriteMonoRGBAPixelsBack(const GLcontext *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; -//---- private methods ---------- + assert(bitmap); -void BGLView::_ReservedGLView1() {} -void BGLView::_ReservedGLView2() {} -void BGLView::_ReservedGLView3() {} -void BGLView::_ReservedGLView4() {} -void BGLView::_ReservedGLView5() {} -void BGLView::_ReservedGLView6() {} -void BGLView::_ReservedGLView7() {} -void BGLView::_ReservedGLView8() {} + uint32 pixel_color = PACK_B_RGBA32(color); +#if 0 + while(n--) { + if (*mask++) { + int row = md->m_bottom - *y; + uint8 * pixel = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + *x * 4; -#if 0 -BGLView::BGLView(const BGLView &v) - : BView(v) -{ - // XXX not sure how this should work - printf("Warning BGLView::copy constructor not implemented\n"); -} + *((uint32 *) pixel) = pixel_color; + }; + x++; + y++; + }; +#else + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + GLubyte * ptr = (GLubyte *) bitmap->Bits() + + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4; + *((uint32 *) ptr) = pixel_color; + } + } + } + else { + for (GLuint i = 0; i < n; i++) { + GLubyte * ptr = (GLubyte *) bitmap->Bits() + + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4; + *((uint32 *) ptr) = pixel_color; + } + } #endif +} -BGLView &BGLView::operator=(const BGLView &v) +void MesaDriver::WriteCI32SpanBack( const GLcontext *ctx, GLuint n, + GLint x, GLint y, + const GLuint index[], const GLubyte mask[] ) { - printf("Warning BGLView::operator= not implemented\n"); + printf("WriteCI32SpanBack() not implemented yet!\n"); + // TODO } -void BGLView::dither_front() +void MesaDriver::WriteCI8SpanBack( const GLcontext *ctx, GLuint n, + GLint x, GLint y, + const GLubyte index[], const GLubyte mask[] ) { - // no-op + printf("WriteCI8SpanBack() not implemented yet!\n"); + // TODO } -bool BGLView::confirm_dither() +void MesaDriver::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n, + GLint x, GLint y, + GLuint colorIndex, const GLubyte mask[] ) { - // no-op - return false; + printf("WriteMonoCISpanBack() not implemented yet!\n"); + // TODO } -void BGLView::draw(BRect r) + +void MesaDriver::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + const GLuint index[], const GLubyte mask[] ) { - // XXX no-op ??? + printf("WriteCI32PixelsBack() not implemented yet!\n"); + // TODO } -/* Direct Window stuff */ -void BGLView::drawScanline( int x1, int x2, int y, void *data ) +void MesaDriver::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + GLuint colorIndex, const GLubyte mask[] ) { - // no-op + printf("WriteMonoCIPixelsBack() not implemented yet!\n"); + // TODO } -void BGLView::scanlineHandler(struct rasStateRec *state, - GLint x1, GLint x2) + +void MesaDriver::ReadCI32SpanBack( const GLcontext *ctx, + GLuint n, GLint x, GLint y, GLuint index[] ) { - // no-op + printf("ReadCI32SpanBack() not implemented yet!\n"); + // TODO } -void BGLView::lock_draw() + +void MesaDriver::ReadRGBASpanBack( const GLcontext *ctx, GLuint n, + GLint x, GLint y, GLubyte rgba[][4] ) { - // no-op + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + const BBitmap *bitmap = md->m_bitmap; + assert(bitmap); + int row = md->m_bottom - y; + const GLubyte *pixel = (GLubyte *) bitmap->Bits() + + (row * bitmap->BytesPerRow()) + x * 4; + + for (GLuint i = 0; i < n; i++) { + rgba[i][RCOMP] = pixel[BE_RCOMP]; + rgba[i][GCOMP] = pixel[BE_GCOMP]; + rgba[i][BCOMP] = pixel[BE_BCOMP]; + rgba[i][ACOMP] = pixel[BE_ACOMP]; + pixel += 4; + } } -void BGLView::unlock_draw() + +void MesaDriver::ReadCI32PixelsBack( const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + GLuint indx[], const GLubyte mask[] ) { - // no-op + printf("ReadCI32PixelsBack() not implemented yet!\n"); + // TODO } -bool BGLView::validateView() + +void MesaDriver::ReadRGBAPixelsBack( const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + GLubyte rgba[][4], const GLubyte mask[] ) { - // no-op - return true; -} + MesaDriver *md = (MesaDriver *) ctx->DriverCtx; + const BBitmap *bitmap = md->m_bitmap; + assert(bitmap); + + if (mask) { + for (GLuint i = 0; i < n; i++) { + if (mask[i]) { + GLubyte *pixel = (GLubyte *) bitmap->Bits() + + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4; + rgba[i][RCOMP] = pixel[BE_RCOMP]; + rgba[i][GCOMP] = pixel[BE_GCOMP]; + rgba[i][BCOMP] = pixel[BE_BCOMP]; + rgba[i][ACOMP] = pixel[BE_ACOMP]; + }; + }; + } else { + for (GLuint i = 0; i < n; i++) { + GLubyte *pixel = (GLubyte *) bitmap->Bits() + + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4; + rgba[i][RCOMP] = pixel[BE_RCOMP]; + rgba[i][GCOMP] = pixel[BE_GCOMP]; + rgba[i][BCOMP] = pixel[BE_BCOMP]; + rgba[i][ACOMP] = pixel[BE_ACOMP]; + }; + }; +} + +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 +}; +