summaryrefslogtreecommitdiff
path: root/src/mesa/drivers/beos
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa/drivers/beos')
-rw-r--r--src/mesa/drivers/beos/GLView.cpp1519
1 files changed, 855 insertions, 664 deletions
diff --git a/src/mesa/drivers/beos/GLView.cpp b/src/mesa/drivers/beos/GLView.cpp
index 56c1b7773b..b96b4e8289 100644
--- a/src/mesa/drivers/beos/GLView.cpp
+++ b/src/mesa/drivers/beos/GLView.cpp
@@ -1,4 +1,4 @@
-/* $Id: GLView.cpp,v 1.5 2000/11/17 21:01:26 brianp Exp $ */
+/* $Id: GLView.cpp,v 1.6 2002/09/19 16:19:45 brianp Exp $ */
/*
* Mesa 3-D graphics library
@@ -27,6 +27,9 @@
/*
* $Log: GLView.cpp,v $
+ * Revision 1.6 2002/09/19 16:19:45 brianp
+ * Updated BeOS support (Philippe Houdoin)
+ *
* Revision 1.5 2000/11/17 21:01:26 brianp
* Minor header file changes to silence warnings.
* Added _mesa_enable_sw_extensions(), called by software-only drivers
@@ -70,14 +73,39 @@
* Initial revision
*/
-
+#include "glheader.h"
#include <assert.h>
#include <stdio.h>
-#include <GLView.h>
-#include "../src/context.h"
+
+extern "C" {
+
+#include "context.h"
+#include "colormac.h"
+#include "depth.h"
#include "extensions.h"
+#include "macros.h"
+#include "matrix.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "texformat.h"
+#include "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"
+
+} // extern "C"
+#include <GLView.h>
// BeOS component ordering for B_RGBA32 bitmap format
#define BE_RCOMP 2
@@ -85,6 +113,13 @@
#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)
+
+#define FLIP(coord) (LIBGGI_MODE(ggi_ctx->ggi_visual)->visible.y-(coord) - 1)
//
// This object hangs off of the BGLView object. We have to use
@@ -92,317 +127,705 @@
// 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
{
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;
+ 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;
+
+ GLubyte m_clear_color[4]; // buffer clear color
+ GLuint m_clear_index; // buffer clear color index
+ GLint m_bottom; // used for flipping Y coords
+ GLuint m_width;
+ GLuint m_height;
+
+ // Mesa Device Driver functions
+ static void UpdateState(GLcontext *ctx, GLuint new_state);
+ static void ClearIndex(GLcontext *ctx, GLuint index);
+ static void ClearColor(GLcontext *ctx, const GLchan color[4]);
+ static void Clear(GLcontext *ctx, GLbitfield mask,
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 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, resizingMode, 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;
+ 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
+ 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
+ );
+
+ // create core context
+ __GLimports imports;
+ _mesa_init_default_imports(&imports, md);
+ GLcontext * ctx = _mesa_create_context( visual, NULL, &imports);
+
+
+ // 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
+ );
+
+ _mesa_enable_sw_extensions(ctx);
+ _mesa_enable_1_3_extensions(ctx);
+
+ /* Initialize the software rasterizer and helper modules.
+ */
+
+ _swrast_CreateContext(ctx);
+ _ac_CreateContext(ctx);
+ _tnl_CreateContext(ctx);
+ _swsetup_CreateContext(ctx);
+
+ _swsetup_Wakeup(ctx);
+
+ md->Init(this, ctx, visual, buffer );
+
+ // Hook aux data into BGLView object
+ m_gc = md;
}
-AuxInfo::~AuxInfo()
+BGLView::~BGLView()
{
+ printf("BGLView destructor\n");
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ delete md;
+}
- _mesa_destroy_visual(mVisual);
- _mesa_destroy_framebuffer(mBuffer);
- _mesa_destroy_context(mContext);
+void BGLView::LockGL()
+{
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->LockGL();
}
+void BGLView::UnlockGL()
+{
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->UnlockGL();
+}
-void AuxInfo::Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b)
+void BGLView::SwapBuffers()
{
- mBGLView = bglView;
- mContext = c;
- mVisual = v;
- mBuffer = b;
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->SwapBuffers();
}
-void AuxInfo::MakeCurrent()
+void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height)
{
- UpdateState(mContext);
- _mesa_make_current(mContext, mBuffer);
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->CopySubBuffer(x, y, width, height);
}
-void AuxInfo::SwapBuffers() const
+BView * BGLView::EmbeddedView()
{
- if (mBitmap) {
- mBGLView->DrawBitmap(mBitmap, BPoint(0, 0));
- }
+ // XXX to do
+ return NULL;
+}
+
+status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
+{
+ // XXX to do
+ printf("BGLView::CopyPixelsOut() not implemented yet!\n");
+ return B_UNSUPPORTED;
}
-void AuxInfo::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const
+status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
+{
+ // XXX to do
+ printf("BGLView::CopyPixelsIn() not implemented yet!\n");
+ return B_UNSUPPORTED;
+}
+
+void BGLView::ErrorCallback(unsigned long errorCode) // GLenum errorCode)
+{
+ // XXX to do
+ printf("BGLView::ErrorCallback() not implemented yet!\n");
+ return;
+}
+
+void BGLView::Draw(BRect updateRect)
+{
+ // printf("BGLView::Draw()\n");
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->Draw(updateRect);
+}
+
+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)
{
- if (mBitmap) {
+ 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");
+ return *this;
+}
+
+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;
+}
+
+// #pragma mark -
+
+MesaDriver::MesaDriver()
+{
+ 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;
+
+ m_clear_index = 0;
+}
+
+
+MesaDriver::~MesaDriver()
+{
+ _mesa_destroy_visual(m_glvisual);
+ _mesa_destroy_framebuffer(m_glframebuffer);
+ _mesa_destroy_context(m_glcontext);
+
+}
+
+
+void MesaDriver::Init(BGLView * bglview, GLcontext * ctx, GLvisual * visual, GLframebuffer * framebuffer)
+{
+ 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 );
+
+ ctx->Driver.GetString = MesaDriver::GetString;
+ ctx->Driver.UpdateState = MesaDriver::UpdateState;
+ ctx->Driver.GetBufferSize = MesaDriver::GetBufferSize;
+ ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
+
+ ctx->Driver.Accum = _swrast_Accum;
+ ctx->Driver.Bitmap = _swrast_Bitmap;
+ ctx->Driver.ClearIndex = MesaDriver::ClearIndex;
+ ctx->Driver.ClearColor = MesaDriver::ClearColor;
+ ctx->Driver.Clear = MesaDriver::Clear;
+ ctx->Driver.CopyPixels = _swrast_CopyPixels;
+ ctx->Driver.DrawPixels = _swrast_DrawPixels;
+ ctx->Driver.ReadPixels = _swrast_ReadPixels;
+
+ ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
+ ctx->Driver.TexImage1D = _mesa_store_teximage1d;
+ ctx->Driver.TexImage2D = _mesa_store_teximage2d;
+ ctx->Driver.TexImage3D = _mesa_store_teximage3d;
+ ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
+ ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
+ ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
+ ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
+
+ ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
+ ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
+ ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
+ ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
+ ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
+ ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
+ ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
+ ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
+ ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
+
+ ctx->Driver.BaseCompressedTexFormat = _mesa_base_compressed_texformat;
+ ctx->Driver.CompressedTextureSize = _mesa_compressed_texture_size;
+ ctx->Driver.GetCompressedTexImage = _mesa_get_compressed_teximage;
+
+ swdd->SetBuffer = MesaDriver::SetBuffer;
+
+ tnl->Driver.RunPipeline = _tnl_run_pipeline;
+
+ _swsetup_Wakeup(ctx);
+}
+
+
+void MesaDriver::LockGL()
+{
+ m_bglview->LockLooper();
+
+ UpdateState(m_glcontext, 0);
+ _mesa_make_current(m_glcontext, m_glframebuffer);
+}
+
+
+void MesaDriver::UnlockGL()
+{
+ m_bglview->UnlockLooper();
+ // Could call _mesa_make_current(NULL, NULL) but it would just
+ // hinder performance
+}
+
+
+void MesaDriver::SwapBuffers() const
+{
+ // _mesa_swap_buffers();
+
+ if (m_bitmap) {
+ m_bglview->LockLooper();
+ m_bglview->DrawBitmap(m_bitmap, BPoint(0, 0));
+ m_bglview->UnlockLooper();
+ };
+}
+
+
+void MesaDriver::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const
+{
+ 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 = mBottom - y;
+ srcAndDest.bottom = m_bottom - y;
srcAndDest.top = srcAndDest.bottom - height + 1;
- mBGLView->DrawBitmap(mBitmap, srcAndDest, srcAndDest);
+ m_bglview->DrawBitmap(m_bitmap, srcAndDest, srcAndDest);
}
}
-void AuxInfo::UpdateState( GLcontext *ctx )
+void MesaDriver::Draw(BRect updateRect) const
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+ if (m_bitmap)
+ m_bglview->DrawBitmap(m_bitmap, updateRect, updateRect);
+}
- assert(aux->mContext == ctx );
- 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;
+void MesaDriver::UpdateState( GLcontext *ctx, GLuint new_state )
+{
+ struct swrast_device_driver * swdd = _swrast_GetDeviceDriverReference( ctx );
+
+ _swrast_InvalidateState( ctx, new_state );
+ _swsetup_InvalidateState( ctx, new_state );
+ _ac_InvalidateState( ctx, new_state );
+ _tnl_InvalidateState( ctx, new_state );
- if (ctx->Color.DrawBuffer == GL_FRONT) {
+ 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;
+ 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 */
- 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;
+ 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::ClearIndex(GLcontext *ctx, GLuint index)
+void MesaDriver::ClearIndex(GLcontext *ctx, GLuint index)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- aux->mClearIndex = index;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ md->m_clear_index = index;
}
-void AuxInfo::ClearColor(GLcontext *ctx, GLubyte r, GLubyte g,
- GLubyte b, GLubyte a)
+void MesaDriver::ClearColor(GLcontext *ctx, const GLchan color[4])
+ // 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);
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ md->m_clear_color[BE_RCOMP] = color[0];
+ md->m_clear_color[BE_GCOMP] = color[1];
+ md->m_clear_color[BE_BCOMP] = color[2];
+ md->m_clear_color[BE_ACOMP] = color[3];
+ assert(md->m_bglview);
}
-GLbitfield AuxInfo::Clear(GLcontext *ctx, GLbitfield mask,
+void MesaDriver::Clear(GLcontext *ctx, GLbitfield mask,
GLboolean all, GLint x, GLint y,
GLint width, GLint height)
{
if (mask & DD_FRONT_LEFT_BIT)
- ClearFront(ctx, all, x, y, width, height);
+ 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);
+ 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;
}
-void AuxInfo::ClearFront(GLcontext *ctx,
+void MesaDriver::ClearFront(GLcontext *ctx,
GLboolean all, GLint x, GLint y,
GLint width, GLint height)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
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]);
+ 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);
@@ -412,40 +835,40 @@ void AuxInfo::ClearFront(GLcontext *ctx,
BRect b;
b.left = x;
b.right = x + width;
- b.bottom = aux->mHeight - y - 1;
+ b.bottom = md->m_height - y - 1;
b.top = b.bottom - height;
bglview->FillRect(b);
}
// 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]);
+ 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
}
-void AuxInfo::ClearBack(GLcontext *ctx,
+void MesaDriver::ClearBack(GLcontext *ctx,
GLboolean all, GLint x, GLint y,
GLint width, GLint height)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
assert(bglview);
- BBitmap *bitmap = aux->mBitmap;
+ BBitmap *bitmap = md->m_bitmap;
assert(bitmap);
GLuint *start = (GLuint *) bitmap->Bits();
- const GLuint *clearPixelPtr = (const GLuint *) aux->mClearColor;
+ const GLuint *clearPixelPtr = (const GLuint *) md->m_clear_color;
const GLuint clearPixel = *clearPixelPtr;
if (all) {
- const int numPixels = aux->mWidth * aux->mHeight;
+ const int numPixels = md->m_width * md->m_height;
if (clearPixel == 0) {
memset(start, 0, numPixels * 4);
}
@@ -457,68 +880,66 @@ void AuxInfo::ClearBack(GLcontext *ctx,
}
else {
// XXX untested
- start += y * aux->mWidth + x;
+ start += y * md->m_width + x;
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
start[j] = clearPixel;
}
- start += aux->mWidth;
+ start += md->m_width;
}
}
}
-GLboolean AuxInfo::SetDrawBuffer(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::SetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
- GLenum buffer)
+void MesaDriver::SetBuffer(GLcontext *ctx, GLframebuffer *buffer,
+ GLenum mode)
{
- /* XXX to do */
+ /* TODO */
+ (void) ctx;
+ (void) buffer;
+ (void) mode;
}
-void AuxInfo::GetBufferSize(GLcontext *ctx, GLuint *width,
+void MesaDriver::GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
GLuint *height)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
+ GET_CURRENT_CONTEXT(ctx);
+ if (!ctx)
+ return;
+
+ MesaDriver * md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
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;
+ *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->DBflag) {
- if (*width != aux->mWidth || *height != aux->mHeight) {
+ if (ctx->Visual.doubleBufferMode) {
+ if (*width != md->m_width || *height != md->m_height) {
// allocate new size of back buffer bitmap
- if (aux->mBitmap)
- delete aux->mBitmap;
+ if (md->m_bitmap)
+ delete md->m_bitmap;
BRect rect(0.0, 0.0, *width - 1, *height - 1);
- aux->mBitmap = new BBitmap(rect, B_RGBA32);
+ md->m_bitmap = new BBitmap(rect, B_RGBA32);
}
}
else
{
- aux->mBitmap = NULL;
+ md->m_bitmap = NULL;
}
- aux->mWidth = *width;
- aux->mHeight = *height;
+ md->m_width = *width;
+ md->m_height = *height;
}
-const GLubyte *AuxInfo::GetString(GLcontext *ctx, GLenum name)
+const GLubyte *MesaDriver::GetString(GLcontext *ctx, GLenum name)
{
switch (name) {
case GL_RENDERER:
- return (const GLubyte *) "Mesa BeOS";
+ return (const GLubyte *) "Mesa BGLView (software)";
default:
// Let core library handle all other cases
return NULL;
@@ -536,15 +957,15 @@ static void Plot(BGLView *bglview, int x, int y)
}
-void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::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;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
assert(bglview);
- int flippedY = aux->mBottom - y;
+ int flippedY = md->m_bottom - y;
if (mask) {
for (GLuint i = 0; i < n; i++) {
if (mask[i]) {
@@ -561,15 +982,15 @@ void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
}
}
-void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::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;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
assert(bglview);
- int flippedY = aux->mBottom - y;
+ int flippedY = md->m_bottom - y;
if (mask) {
for (GLuint i = 0; i < n; i++) {
if (mask[i]) {
@@ -586,15 +1007,15 @@ void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
}
}
-void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
GLint x, GLint y,
const GLchan color[4],
const GLubyte mask[])
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
assert(bglview);
- int flippedY = aux->mBottom - y;
+ int flippedY = md->m_bottom - y;
bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]);
if (mask) {
for (GLuint i = 0; i < n; i++) {
@@ -610,69 +1031,69 @@ void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
}
}
-void AuxInfo::WriteRGBAPixelsFront(const GLcontext *ctx,
+void MesaDriver::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;
+ 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], aux->mBottom - y[i]);
+ 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], aux->mBottom - y[i]);
+ Plot(bglview, x[i], md->m_bottom - y[i]);
}
}
}
-void AuxInfo::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLchan color[4],
const GLubyte mask[])
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
+ 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], aux->mBottom - y[i]);
+ Plot(bglview, x[i], md->m_bottom - y[i]);
}
}
}
else {
for (GLuint i = 0; i < n; i++) {
- Plot(bglview, x[i], aux->mBottom - y[i]);
+ Plot(bglview, x[i], md->m_bottom - y[i]);
}
}
}
-void AuxInfo::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+void MesaDriver::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,
+void MesaDriver::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,
+void MesaDriver::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
GLint x, GLint y,
GLuint colorIndex, const GLubyte mask[] )
{
@@ -680,14 +1101,14 @@ void AuxInfo::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
}
-void AuxInfo::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::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,
+void MesaDriver::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[] )
{
@@ -695,147 +1116,182 @@ void AuxInfo::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
}
-void AuxInfo::ReadCI32SpanFront( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanFront( const GLcontext *ctx,
GLuint n, GLint x, GLint y, GLuint index[] )
{
- // XXX to do
+ printf("ReadCI32SpanFront() not implemented yet!\n");
+ // XXX to do
}
-void AuxInfo::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
GLint x, GLint y, GLubyte rgba[][4] )
{
+ printf("ReadRGBASpanFront() not implemented yet!\n");
// XXX to do
}
-void AuxInfo::ReadCI32PixelsFront( const GLcontext *ctx,
+void MesaDriver::ReadCI32PixelsFront( const GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] )
{
+ printf("ReadCI32PixelsFront() not implemented yet!\n");
// XXX to do
}
-void AuxInfo::ReadRGBAPixelsFront( const GLcontext *ctx,
+void MesaDriver::ReadRGBAPixelsFront( const GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte rgba[][4], const GLubyte mask[] )
{
+ printf("ReadRGBAPixelsFront() not implemented yet!\n");
// XXX to do
}
-void AuxInfo::WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::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,
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ static bool already_called = false;
+ if (! already_called) {
+ printf("WriteRGBASpanBack() called.\n");
+ already_called = true;
+ }
+
+ assert(bitmap);
+
+ int row = md->m_bottom - y;
+ 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[])
{
- 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;
- }
- }
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ static bool already_called = false;
+ if (! already_called) {
+ printf("WriteRGBSpanBack() called.\n");
+ already_called = true;
+ }
+
+ assert(bitmap);
+
+ int row = md->m_bottom - y;
+ 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 AuxInfo::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
+
+
+void MesaDriver::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
GLint x, GLint y,
const GLchan color[4], 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;
- 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;
- }
- }
-}
-
-
-void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx,
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ static bool already_called = false;
+ if (! already_called) {
+ printf("WriteMonoRGBASpanBack() called.\n");
+ already_called = true;
+ }
+
+ assert(bitmap);
+
+ int row = md->m_bottom - y;
+ 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 MesaDriver::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);
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ static bool already_called = false;
+ if (! already_called) {
+ printf("WriteRGBAPixelsBack() called.\n");
+ already_called = true;
+ }
+
+ assert(bitmap);
+#if 0
+ while(n--) {
+ 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()
- + (aux->mBottom - y[i]) * bitmap->BytesPerRow() + x[i] * 4;
+ + ((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];
@@ -846,64 +1302,81 @@ void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx,
else {
for (GLuint i = 0; i < n; i++) {
GLubyte *pixel = (GLubyte *) bitmap->Bits()
- + (aux->mBottom - y[i]) * bitmap->BytesPerRow() + x[i] * 4;
+ + ((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 AuxInfo::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
const GLchan color[4],
const GLubyte mask[])
{
- 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);
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ static bool already_called = false;
+ if (! already_called) {
+ printf("WriteMonoRGBAPixelsBack() called.\n");
+ already_called = true;
+ }
+
+ assert(bitmap);
+
+ uint32 pixel_color = PACK_B_RGBA32(color);
+#if 0
+ while(n--) {
+ if (*mask++) {
+ int row = md->m_bottom - *y;
+ uint8 * pixel = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + *x * 4;
+
+ *((uint32 *) pixel) = pixel_color;
+ };
+ x++;
+ y++;
+ };
+#else
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;
+ 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++) {
- GLuint *pixelPtr = (GLuint *) bitmap->Bits()
- + (aux->mBottom - y[i]) * aux->mWidth + x[i];
- *pixelPtr = pixel;
+ 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
}
-void AuxInfo::WriteCI32SpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::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,
+void MesaDriver::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,
+void MesaDriver::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
GLint x, GLint y,
GLuint colorIndex, const GLubyte mask[] )
{
@@ -911,14 +1384,14 @@ void AuxInfo::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
}
-void AuxInfo::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::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,
+void MesaDriver::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[] )
{
@@ -926,22 +1399,23 @@ void AuxInfo::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
}
-void AuxInfo::ReadCI32SpanBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanBack( const GLcontext *ctx,
GLuint n, GLint x, GLint y, GLuint index[] )
{
// XXX to do
}
-void AuxInfo::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
GLint x, GLint y, GLubyte rgba[][4] )
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- const BBitmap *bitmap = aux->mBitmap;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ const BBitmap *bitmap = md->m_bitmap;
assert(bitmap);
- int row = aux->mBottom - y;
+ int row = md->m_bottom - y;
const GLubyte *pixel = (GLubyte *) bitmap->Bits()
- + row * bitmap->BytesPerRow() + x * 4;
+ + (row * bitmap->BytesPerRow()) + x * 4;
+
for (GLuint i = 0; i < n; i++) {
rgba[i][RCOMP] = pixel[BE_RCOMP];
rgba[i][GCOMP] = pixel[BE_GCOMP];
@@ -952,7 +1426,7 @@ void AuxInfo::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
}
-void AuxInfo::ReadCI32PixelsBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32PixelsBack( const GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] )
{
@@ -960,319 +1434,36 @@ void AuxInfo::ReadCI32PixelsBack( const GLcontext *ctx,
}
-void AuxInfo::ReadRGBAPixelsBack( const GLcontext *ctx,
+void MesaDriver::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;
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ const BBitmap *bitmap = md->m_bitmap;
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;
+
+ 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];
- }
- }
-}
-
-
-
-
-//------------------------------------------------------------------
-// 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 = _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
- );
-
- // create core context
- const GLboolean direct = GL_TRUE;
- GLcontext *ctx = _mesa_create_context( visual, NULL, aux, direct );
-
- _mesa_enable_sw_extensions(ctx);
-
- 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 _mesa_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;
-}