Initial revision

1 files changed, 1233 insertions, 0 deletions

diff --git a/src/mesa/drivers/beos/GLView.cpp b/src/mesa/drivers/beos/GLView.cpp
new file mode 100644
index 0000000000..4332f97b20
--- /dev/null
+++ b/src/mesa/drivers/beos/GLView.cpp
@@ -0,0 +1,1233 @@
+/* $Id: GLView.cpp,v 1.1 1999/08/19 00:55:41 jtg Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * $Log: GLView.cpp,v $
+ * Revision 1.1  1999/08/19 00:55:41  jtg
+ * Initial revision
+ *
+ * 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 <assert.h>
+#include <stdio.h>
+#include <GLView.h>
+#include "../src/context.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
+
+
+//
+// This object hangs off of the BGLView object.  We have to use
+// Be's BGLView class as-is to maintain binary compatibility (we
+// 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
+{
+public:
+   AuxInfo();
+   ~AuxInfo();
+   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;
+
+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 mColor[4];       // current color
+   GLuint mIndex;           // current color index
+   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 ClearFront(GLcontext *ctx, GLbitfield mask,
+                                GLboolean all, GLint x, GLint y,
+                                GLint width, GLint height);
+   static GLbitfield ClearBack(GLcontext *ctx, GLbitfield mask,
+                               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,
+                     GLubyte b, GLubyte a);
+   static GLboolean SetBuffer(GLcontext *ctx, GLenum mode);
+   static void GetBufferSize(GLcontext *ctgx, GLuint *width,
+                             GLuint *height);
+   static const GLubyte *GetString(GLcontext *ctx, GLenum name);
+
+   // Front-buffer functions
+   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,
+                                 GLint x, GLint y,
+                                 CONST GLubyte rgba[][3],
+                                 const GLubyte mask[]);
+   static void WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+                                      GLint x, GLint y, const GLubyte mask[]);
+   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,
+                                        const GLint x[], const GLint y[],
+                                        const GLubyte mask[]);
+   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,
+                                 GLint x, GLint y,
+                                 const GLubyte index[], const GLubyte mask[]);
+   static void WriteMonoCISpanFront(const GLcontext *ctx, GLuint n,
+                                    GLint x, GLint y, const GLubyte mask[]);
+   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,
+                                      const GLint x[], const GLint y[],
+                                      const GLubyte mask[]);
+   static void ReadCI32SpanFront(const GLcontext *ctx,
+                                 GLuint n, GLint x, GLint y, GLuint index[]);
+   static void ReadRGBASpanFront(const GLcontext *ctx, GLuint n,
+                                 GLint x, GLint y,
+                                 GLubyte rgba[][4]);
+   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,
+                                   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,
+                                  GLint x, GLint y,
+                                  CONST GLubyte rgba[][4],
+                                  const GLubyte mask[]);
+   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,
+                                      GLint x, GLint y, const GLubyte mask[]);
+   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,
+                                        const GLint x[], const GLint y[],
+                                        const GLubyte mask[]);
+   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,
+                                const GLubyte index[], const GLubyte mask[]);
+   static void WriteMonoCISpanBack(const GLcontext *ctx, GLuint n,
+                                   GLint x, GLint y,
+                                   const GLubyte mask[]);
+   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,
+                                     GLuint n, const GLint x[], const GLint y[],
+                                     const GLubyte mask[]);
+   static void ReadCI32SpanBack(const GLcontext *ctx,
+                                GLuint n, GLint x, GLint y, GLuint index[]);
+   static void ReadRGBASpanBack(const GLcontext *ctx, GLuint n,
+                                GLint x, GLint y,
+                                GLubyte rgba[][4]);
+   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,
+                                  GLuint n, const GLint x[], const GLint y[],
+                                  GLubyte rgba[][4], const GLubyte mask[]);
+
+};
+
+
+
+AuxInfo::AuxInfo()
+{
+   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;
+   mColor[BE_RCOMP] = 255;
+   mColor[BE_GCOMP] = 255;
+   mColor[BE_BCOMP] = 255;
+   mColor[BE_ACOMP] = 255;
+   mIndex = 1;
+}
+
+
+AuxInfo::~AuxInfo()
+{
+
+   gl_destroy_visual(mVisual);
+   gl_destroy_framebuffer(mBuffer);
+   gl_destroy_context(mContext);
+}
+
+
+void AuxInfo::Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b)
+{
+   mBGLView = bglView;
+   mContext = c;
+   mVisual = v;
+   mBuffer = b;
+}
+
+
+void AuxInfo::MakeCurrent()
+{
+   UpdateState(mContext);
+   gl_make_current(mContext, mBuffer);
+}
+
+
+void AuxInfo::SwapBuffers() const
+{
+   if (mBitmap) {
+      mBGLView->DrawBitmap(mBitmap, BPoint(0, 0));
+   }
+}
+
+
+void AuxInfo::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const
+{
+   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);
+   }
+}
+
+
+void AuxInfo::UpdateState( GLcontext *ctx )
+{
+   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+
+   assert(aux->mContext == ctx );
+
+   ctx->Driver.UpdateState = AuxInfo::UpdateState;
+   ctx->Driver.SetBuffer = AuxInfo::SetBuffer;
+   ctx->Driver.Color = AuxInfo::Color;
+   ctx->Driver.Index = AuxInfo::Index;
+   ctx->Driver.ClearIndex = AuxInfo::ClearIndex;
+   ctx->Driver.ClearColor = AuxInfo::ClearColor;
+   ctx->Driver.GetBufferSize = AuxInfo::GetBufferSize;
+   ctx->Driver.GetString = AuxInfo::GetString;
+
+   if (ctx->Color.DrawBuffer == GL_FRONT) {
+      /* read/write front buffer */
+      ctx->Driver.Clear = AuxInfo::ClearFront;
+      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.Clear = AuxInfo::ClearBack;
+      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;
+    }
+}
+
+
+void AuxInfo::ClearIndex(GLcontext *ctx, GLuint index)
+{
+   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+   aux->mClearIndex = index;
+}
+
+
+void AuxInfo::ClearColor(GLcontext *ctx, GLubyte r, GLubyte g,
+                         GLubyte b, GLubyte a)
+{
+   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);
+}
+
+
+GLbitfield AuxInfo::ClearFront(GLcontext *ctx, GLbitfield mask,
+                               GLboolean all, GLint x, GLint y,
+                               GLint width, GLint height)
+{
+   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);
+   }
+
+   // restore drawing color
+   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]);
+   
+   return mask & (~GL_COLOR_BUFFER_BIT);
+}
+
+
+GLbitfield AuxInfo::ClearBack(GLcontext *ctx, GLbitfield mask,
+                               GLboolean all, GLint x, GLint y,
+                               GLint width, GLint 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;
+
+   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;
+      }
+   }
+
+   return mask & (~GL_COLOR_BUFFER_BIT);
+}
+
+
+void AuxInfo::Index(GLcontext *ctx, GLuint index)
+{
+   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+   BGLView *bglview = aux->mBGLView;
+   assert(bglview);
+   aux->mIndex = index;
+}
+
+
+void AuxInfo::Color(GLcontext *ctx, GLubyte r, GLubyte g,
+						GLubyte b, GLubyte a)
+{
+   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+   BGLView *bglview = aux->mBGLView;
+   assert(bglview);
+   aux->mColor[BE_RCOMP] = r;
+   aux->mColor[BE_GCOMP] = g;
+   aux->mColor[BE_BCOMP] = b;
+   aux->mColor[BE_ACOMP] = a;
+   bglview->SetHighColor(r, g, b, a);
+   bglview->SetLowColor(r, g, b, a);
+}
+
+GLboolean AuxInfo::SetBuffer(GLcontext *ctx, GLenum buffer)
+{
+   if (buffer == GL_FRONT_LEFT)
+      return GL_TRUE;
+   else if (buffer == GL_BACK_LEFT)
+      return GL_TRUE;
+   else
+      return GL_FALSE;
+}
+
+void AuxInfo::GetBufferSize(GLcontext *ctx, GLuint *width,
+                            GLuint *height)
+{
+   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;
+
+   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;
+   }
+
+   aux->mWidth = *width;
+   aux->mHeight = *height;
+}
+
+
+const GLubyte *AuxInfo::GetString(GLcontext *ctx, GLenum name)
+{
+   switch (name) {
+      case GL_RENDERER:
+         return (const GLubyte *) "Mesa BeOS";
+      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)
+{
+   // XXX There's got to be a better way!
+   BPoint p(x, y), q(x+1, y);
+   bglview->StrokeLine(p, q);
+}
+
+
+void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+                                 GLint x, GLint y,
+                                 CONST GLubyte rgba[][4],
+                                 const GLubyte mask[])
+{
+   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);
+      }
+   }
+}
+
+void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+                                GLint x, GLint y,
+                                CONST GLubyte rgba[][3],
+                                const GLubyte mask[])
+{
+   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);
+      }
+   }
+}
+
+void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+                                     GLint x, GLint y, const GLubyte mask[])
+{
+   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]) {
+            Plot(bglview, x++, flippedY);
+         }
+      }
+   }
+   else {
+      for (GLuint i = 0; i < n; i++) {
+         Plot(bglview, x++, flippedY);
+      }
+   }
+}
+
+void AuxInfo::WriteRGBAPixelsFront(const GLcontext *ctx,
+                                   GLuint n, const GLint x[], const GLint y[],
+                                   CONST GLubyte rgba[][4],
+                                   const GLubyte mask[] )
+{
+   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]);
+      }
+   }
+}
+
+
+void AuxInfo::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+                                       const GLint x[], const GLint y[],
+                                       const GLubyte mask[])
+{
+   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+   BGLView *bglview = aux->mBGLView;
+   assert(bglview);
+   // plot points using current color
+   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]);
+      }
+   }
+}
+
+
+void AuxInfo::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                             const GLuint index[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+void AuxInfo::WriteCI8SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            const GLubyte index[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+void AuxInfo::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
+                               GLint x, GLint y, const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n,
+                                    const GLint x[], const GLint y[],
+                                    const GLuint index[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+void AuxInfo::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
+                                      const GLint x[], const GLint y[],
+                                      const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadCI32SpanFront( const GLcontext *ctx,
+                                 GLuint n, GLint x, GLint y, GLuint index[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
+                                 GLint x, GLint y, GLubyte rgba[][4] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadCI32PixelsFront( const GLcontext *ctx,
+                                   GLuint n, const GLint x[], const GLint y[],
+                                   GLuint indx[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadRGBAPixelsFront( const GLcontext *ctx,
+                                   GLuint n, const GLint x[], const GLint y[],
+                                   GLubyte rgba[][4], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+
+
+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;
+      }
+   }
+}
+
+
+void AuxInfo::WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
+                                GLint x, GLint y,
+                                CONST GLubyte rgb[][3],
+                                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] = 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;
+      }
+   }
+}
+
+
+void AuxInfo::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
+                                     GLint x, GLint y, const GLubyte mask[])
+{
+   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;
+   const GLuint pixel = *((GLuint *) aux->mColor);
+   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;
+      }
+   }
+}
+
+
+void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx,
+                                   GLuint n, const GLint x[], const GLint y[],
+                                   CONST GLubyte rgba[][4],
+                                   const GLubyte mask[] )
+{
+   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];
+      }
+   }
+}
+
+
+void AuxInfo::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+                                       const GLint x[], const GLint y[],
+                                       const GLubyte mask[])
+{
+   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+   BBitmap *bitmap = aux->mBitmap;
+   assert(bitmap);
+   const GLuint pixel = *((GLuint *) aux->mColor);
+   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;
+      }
+   }
+}
+
+
+void AuxInfo::WriteCI32SpanBack( const GLcontext *ctx, GLuint n,
+                                 GLint x, GLint y,
+                                 const GLuint index[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+void AuxInfo::WriteCI8SpanBack( const GLcontext *ctx, GLuint n,
+                                GLint x, GLint y,
+                                const GLubyte index[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+void AuxInfo::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
+                                   GLint x, GLint y, const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n,
+                                   const GLint x[], const GLint y[],
+                                   const GLuint index[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+void AuxInfo::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
+                                     const GLint x[], const GLint y[],
+                                     const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadCI32SpanBack( const GLcontext *ctx,
+                                GLuint n, GLint x, GLint y, GLuint index[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
+                                GLint x, GLint y, GLubyte rgba[][4] )
+{
+   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;
+   }
+}
+
+
+void AuxInfo::ReadCI32PixelsBack( const GLcontext *ctx,
+                                   GLuint n, const GLint x[], const GLint y[],
+                                   GLuint indx[], const GLubyte mask[] )
+{
+   // XXX to do
+}
+
+
+void AuxInfo::ReadRGBAPixelsBack( const GLcontext *ctx,
+                                  GLuint n, const GLint x[], const GLint y[],
+                                  GLubyte rgba[][4], const GLubyte mask[] )
+{
+   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];
+      }
+   }
+}
+
+
+
+
+//------------------------------------------------------------------
+// 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)
+{
+   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;
+
+   if (!rgbFlag) {
+      fprintf(stderr, "Mesa Warning: color index mode not supported\n");
+   }
+
+   // Allocate auxiliary data object
+   AuxInfo *aux = new AuxInfo;
+
+   // examine option flags and create gl_context struct
+   GLvisual *visual = gl_create_visual( rgbFlag, alphaFlag,
+                                        dblFlag, stereoFlag,
+                                        depth, stencil, accum, index,
+                                        red, green, blue, alpha);
+
+   // create core framebuffer
+   GLframebuffer *buffer = gl_create_framebuffer(visual);
+
+   // create core context
+   const GLboolean direct = GL_TRUE;
+   GLcontext *ctx = gl_create_context( visual, NULL, aux, direct );
+
+   aux->Init(this, ctx, visual, buffer );
+
+   // Hook aux data into BGLView object
+   m_gc = aux;
+}
+
+
+BGLView::~BGLView()
+{
+   printf("BGLView destructor\n");
+   AuxInfo *aux = (AuxInfo *) m_gc;
+   assert(aux);
+   delete aux;
+}
+
+void BGLView::LockGL()
+{
+   AuxInfo *aux = (AuxInfo *) m_gc;
+   assert(aux);
+   aux->MakeCurrent();
+}
+
+void BGLView::UnlockGL()
+{
+   AuxInfo *aux = (AuxInfo *) m_gc;
+   assert(aux);
+   // Could call gl_make_current(NULL, NULL) but it would just
+   // hinder performance
+}
+
+void BGLView::SwapBuffers()
+{
+   AuxInfo *aux = (AuxInfo *) m_gc;
+   assert(aux);
+   aux->SwapBuffers();
+}
+
+
+void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height)
+{
+   AuxInfo *aux = (AuxInfo *) m_gc;
+   assert(aux);
+   aux->CopySubBuffer(x, y, width, height);
+}
+
+
+BView *BGLView::EmbeddedView()
+{
+   // XXX to do
+
+}
+
+status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
+{
+   // XXX to do
+}
+
+
+status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
+{
+   // XXX to do
+}
+
+void BGLView::ErrorCallback(GLenum errorCode)
+{
+   // XXX to do
+}
+
+void BGLView::Draw(BRect updateRect)
+{
+//   printf("BGLView draw\n");
+   // XXX to do
+}
+
+void BGLView::AttachedToWindow()
+{
+   BView::AttachedToWindow();
+
+   // don't paint window background white when resized
+   SetViewColor(B_TRANSPARENT_32_BIT);
+}
+
+void BGLView::AllAttached()
+{
+   BView::AllAttached();
+//   printf("BGLView AllAttached\n");
+}
+
+void BGLView::DetachedFromWindow()
+{
+   BView::DetachedFromWindow();
+}
+
+void BGLView::AllDetached()
+{
+   BView::AllDetached();
+//   printf("BGLView AllDetached");
+}
+
+void BGLView::FrameResized(float width, float height)
+{
+   return BView::FrameResized(width, height);
+}
+
+status_t BGLView::Perform(perform_code d, void *arg)
+{
+   return BView::Perform(d, arg);
+}
+
+
+status_t BGLView::Archive(BMessage *data, bool deep) const
+{
+   return BView::Archive(data, deep);
+}
+
+void BGLView::MessageReceived(BMessage *msg)
+{
+   BView::MessageReceived(msg);
+}
+
+void BGLView::SetResizingMode(uint32 mode)
+{
+   BView::SetResizingMode(mode);
+}
+
+void BGLView::Show()
+{
+//   printf("BGLView Show\n");
+   BView::Show();
+}
+
+void BGLView::Hide()
+{
+//   printf("BGLView Hide\n");
+   BView::Hide();
+}
+
+BHandler *BGLView::ResolveSpecifier(BMessage *msg, int32 index,
+                                    BMessage *specifier, int32 form,
+                                    const char *property)
+{
+   return BView::ResolveSpecifier(msg, index, specifier, form, property);
+}
+
+status_t BGLView::GetSupportedSuites(BMessage *data)
+{
+   return BView::GetSupportedSuites(data);
+}
+
+void BGLView::DirectConnected( direct_buffer_info *info )
+{
+   // XXX to do
+}
+
+void BGLView::EnableDirectMode( bool enabled )
+{
+   // XXX to do
+}
+
+
+
+//---- private 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
+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");
+}
+
+void BGLView::dither_front()
+{
+   // no-op
+}
+
+bool BGLView::confirm_dither()
+{
+   // no-op
+   return false;
+}
+
+void BGLView::draw(BRect r)
+{
+   // XXX no-op ???
+}
+
+/* Direct Window stuff */
+void BGLView::drawScanline( int x1, int x2, int y, void *data )
+{
+   // no-op
+}
+
+void BGLView::scanlineHandler(struct rasStateRec *state,
+                              GLint x1, GLint x2)
+{
+   // no-op
+}
+
+void BGLView::lock_draw()
+{
+   // no-op
+}
+
+void BGLView::unlock_draw()
+{
+   // no-op
+}
+
+bool BGLView::validateView()
+{
+   // no-op
+   return true;
+}
+