-/* $Id: GLView.cpp,v 1.1 1999/08/19 00:55:41 jtg Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 3.1
+ * Version: 6.1
*
- * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
*/
-/*
- * $Log: GLView.cpp,v $
- * Revision 1.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"
+extern "C" {
+
+#include "glheader.h"
+#include "version.h"
+#include "buffers.h"
+#include "bufferobj.h"
+#include "context.h"
+#include "colormac.h"
+#include "depth.h"
+#include "extensions.h"
+#include "macros.h"
+#include "matrix.h"
+#include "mtypes.h"
+#include "texformat.h"
+#include "texobj.h"
+#include "teximage.h"
+#include "texstore.h"
+#include "array_cache/acache.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "swrast/s_context.h"
+#include "swrast/s_depth.h"
+#include "swrast/s_lines.h"
+#include "swrast/s_triangle.h"
+#include "swrast/s_trispan.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
+
+#include "drivers/common/driverfuncs.h"
+
+} // extern "C"
+
+#include <interface/Screen.h>
+#include <GLView.h>
// BeOS component ordering for B_RGBA32 bitmap format
-#define BE_RCOMP 2
-#define BE_GCOMP 1
-#define BE_BCOMP 0
-#define BE_ACOMP 3
+#if B_HOST_IS_LENDIAN
+ #define BE_RCOMP 2
+ #define BE_GCOMP 1
+ #define BE_BCOMP 0
+ #define BE_ACOMP 3
+
+ #define PACK_B_RGBA32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
+ (color[RCOMP] << 16) | (color[ACOMP] << 24))
+
+ #define PACK_B_RGB32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
+ (color[RCOMP] << 16) | 0xFF000000)
+#else
+ // Big Endian B_RGBA32 bitmap format
+ #define BE_RCOMP 1
+ #define BE_GCOMP 2
+ #define BE_BCOMP 3
+ #define BE_ACOMP 0
+
+ #define PACK_B_RGBA32(color) (color[ACOMP] | (color[RCOMP] << 8) | \
+ (color[GCOMP] << 16) | (color[BCOMP] << 24))
+
+ #define PACK_B_RGB32(color) ((color[RCOMP] << 8) | (color[GCOMP] << 16) | \
+ (color[BCOMP] << 24) | 0xFF000000)
+#endif
+
+#define FLIP(coord) (LIBGGI_MODE(ggi_ctx->ggi_visual)->visible.y-(coord) - 1)
+const char * color_space_name(color_space space);
//
// This object hangs off of the BGLView object. We have to use
// can't add new members to it). Instead we just put all our data
// in this class and use BGLVIew::m_gc to point to it.
//
-class AuxInfo
+class MesaDriver
{
+friend class BGLView;
public:
- AuxInfo();
- ~AuxInfo();
- void Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b);
+ MesaDriver();
+ ~MesaDriver();
+
+ void Init(BGLView * bglview, GLcontext * c, GLvisual * v, GLframebuffer * b);
- void MakeCurrent();
- void SwapBuffers() const;
- void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const;
+ void LockGL();
+ void UnlockGL();
+ void SwapBuffers() const;
+ status_t CopyPixelsOut(BPoint source, BBitmap *dest);
+ status_t CopyPixelsIn(BBitmap *source, BPoint dest);
+
+ void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const;
+ void Draw(BRect updateRect) const;
private:
- AuxInfo(const AuxInfo &rhs); // copy constructor illegal
- AuxInfo &operator=(const AuxInfo &rhs); // assignment oper. illegal
-
- GLcontext *mContext;
- GLvisual *mVisual;
- GLframebuffer *mBuffer;
-
- BGLView *mBGLView;
- BBitmap *mBitmap;
-
- GLubyte 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,
+ MesaDriver(const MesaDriver &rhs); // copy constructor illegal
+ MesaDriver &operator=(const MesaDriver &rhs); // assignment oper. illegal
+
+ GLcontext * m_glcontext;
+ GLvisual * m_glvisual;
+ GLframebuffer * m_glframebuffer;
+
+ BGLView * m_bglview;
+ BBitmap * m_bitmap;
+
+ GLchan m_clear_color[4]; // buffer clear color
+ GLuint m_clear_index; // buffer clear color index
+ GLint m_bottom; // used for flipping Y coords
+ GLuint m_width;
+ GLuint m_height;
+
+ // Mesa Device Driver callback functions
+ static void UpdateState(GLcontext *ctx, GLuint new_state);
+ static void ClearIndex(GLcontext *ctx, GLuint index);
+ static void ClearColor(GLcontext *ctx, const GLfloat color[4]);
+ static void Clear(GLcontext *ctx, GLbitfield mask,
GLboolean all, GLint x, GLint y,
GLint width, GLint height);
- static 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,
+ 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,
+ 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,
+ static void SetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
+ GLenum mode);
+ static void GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
GLuint *height);
- static const GLubyte *GetString(GLcontext *ctx, GLenum name);
+ static void Error(GLcontext *ctx);
+ static const GLubyte * GetString(GLcontext *ctx, GLenum name);
+ static void Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
// 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,
- GLint x, GLint y, const GLubyte mask[]);
- static void WriteRGBAPixelsFront(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,
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,
- GLint x, GLint y, const GLubyte mask[]);
- static void WriteCI32PixelsFront(const GLcontext *ctx,
+ static void WriteMonoCISpanFront(const GLcontext *ctx, GLuint n,
+ GLint x, GLint y,
+ GLuint colorIndex, 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,
+ static void WriteMonoCIPixelsFront(const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
- const GLubyte mask[]);
- static void ReadCI32SpanFront(const GLcontext *ctx,
+ GLuint colorIndex, 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,
+ 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,
- 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,
+ 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,
+ 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 GLchan color[4],
+ 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,
+ 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,
+ 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[],
- const GLubyte mask[]);
- static void ReadCI32SpanBack(const GLcontext *ctx,
+ GLuint colorIndex, 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,
+ static void ReadRGBASpanBack(const GLcontext *ctx, GLuint n,
GLint x, GLint y,
GLubyte rgba[][4]);
- static void ReadCI32PixelsBack(const GLcontext *ctx,
+ static void ReadCI32PixelsBack(const GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[]);
- static void ReadRGBAPixelsBack(const GLcontext *ctx,
+ static void ReadRGBAPixelsBack(const GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte rgba[][4], const GLubyte mask[]);
};
+//------------------------------------------------------------------
+// Public interface methods
+//------------------------------------------------------------------
-AuxInfo::AuxInfo()
+//
+// Input: rect - initial rectangle
+// name - window name
+// resizingMode - example: B_FOLLOW_NONE
+// mode - usually 0 ?
+// options - Bitwise-OR of BGL_* tokens
+//
+BGLView::BGLView(BRect rect, char *name,
+ ulong resizingMode, ulong mode,
+ ulong options)
+ : BView(rect, name, B_FOLLOW_ALL_SIDES, mode | B_WILL_DRAW | B_FRAME_EVENTS) // | B_FULL_UPDATE_ON_RESIZE)
{
- mContext = NULL;
- mVisual = NULL;
- mBuffer = NULL;
- mBGLView = NULL;
- mBitmap = NULL;
- mClearColor[BE_RCOMP] = 0;
- mClearColor[BE_GCOMP] = 0;
- mClearColor[BE_BCOMP] = 0;
- mClearColor[BE_ACOMP] = 0;
- mClearIndex = 0;
- mColor[BE_RCOMP] = 255;
- mColor[BE_GCOMP] = 255;
- mColor[BE_BCOMP] = 255;
- mColor[BE_ACOMP] = 255;
- mIndex = 1;
-}
+ // We don't support single buffering (yet): double buffering forced.
+ options |= BGL_DOUBLE;
+ const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
+ const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
+ const GLboolean dblFlag = ((options & BGL_DOUBLE) == BGL_DOUBLE);
+ const GLboolean stereoFlag = false;
+ const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
+ const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
+ const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
+ const GLint index = (options & BGL_INDEX) ? 32 : 0;
+ const GLint red = rgbFlag ? 8 : 0;
+ const GLint green = rgbFlag ? 8 : 0;
+ const GLint blue = rgbFlag ? 8 : 0;
+ const GLint alpha = alphaFlag ? 8 : 0;
+
+ m_options = options | BGL_INDIRECT;
+
+ struct dd_function_table functions;
+
+ if (!rgbFlag) {
+ fprintf(stderr, "Mesa Warning: color index mode not supported\n");
+ }
+
+ // Allocate auxiliary data object
+ MesaDriver * md = new MesaDriver();
+
+ // examine option flags and create gl_context struct
+ GLvisual * visual = _mesa_create_visual( rgbFlag,
+ dblFlag,
+ stereoFlag,
+ red, green, blue, alpha,
+ index,
+ depth,
+ stencil,
+ accum, accum, accum, accum,
+ 1
+ );
+
+ // Initialize device driver function table
+ _mesa_init_driver_functions(&functions);
+
+ functions.GetString = md->GetString;
+ functions.UpdateState = md->UpdateState;
+ functions.GetBufferSize = md->GetBufferSize;
+ functions.Clear = md->Clear;
+ functions.ClearIndex = md->ClearIndex;
+ functions.ClearColor = md->ClearColor;
+ functions.Error = md->Error;
+ functions.Viewport = md->Viewport;
+
+ // create core context
+ GLcontext *ctx = _mesa_create_context(visual, NULL, &functions, md);
+ if (! ctx) {
+ _mesa_destroy_visual(visual);
+ delete md;
+ return;
+ }
+ _mesa_enable_sw_extensions(ctx);
+ _mesa_enable_1_3_extensions(ctx);
+ _mesa_enable_1_4_extensions(ctx);
+ _mesa_enable_1_5_extensions(ctx);
-AuxInfo::~AuxInfo()
-{
- gl_destroy_visual(mVisual);
- gl_destroy_framebuffer(mBuffer);
- gl_destroy_context(mContext);
+ // create core framebuffer
+ GLframebuffer * buffer = _mesa_create_framebuffer(visual,
+ depth > 0 ? GL_TRUE : GL_FALSE,
+ stencil > 0 ? GL_TRUE: GL_FALSE,
+ accum > 0 ? GL_TRUE : GL_FALSE,
+ alphaFlag
+ );
+
+ /* Initialize the software rasterizer and helper modules.
+ */
+ _swrast_CreateContext(ctx);
+ _ac_CreateContext(ctx);
+ _tnl_CreateContext(ctx);
+ _swsetup_CreateContext(ctx);
+ _swsetup_Wakeup(ctx);
+
+ md->Init(this, ctx, visual, buffer );
+
+ // Hook aux data into BGLView object
+ m_gc = md;
+
+ // some stupid applications (Quake2) don't even think about calling LockGL()
+ // before using glGetString and friends... so make sure there is at least a
+ // valid context.
+ if (!_mesa_get_current_context()) {
+ LockGL();
+ // not needed, we don't have a looper yet: UnlockLooper();
+ }
+
}
-void AuxInfo::Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b)
+BGLView::~BGLView()
{
- mBGLView = bglView;
- mContext = c;
- mVisual = v;
- mBuffer = b;
+ // printf("BGLView destructor\n");
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ delete md;
}
+void BGLView::LockGL()
+{
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->LockGL();
+}
-void AuxInfo::MakeCurrent()
+void BGLView::UnlockGL()
{
- UpdateState(mContext);
- gl_make_current(mContext, mBuffer);
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->UnlockGL();
}
+void BGLView::SwapBuffers()
+{
+ SwapBuffers(false);
+}
-void AuxInfo::SwapBuffers() const
+void BGLView::SwapBuffers(bool vSync)
{
- if (mBitmap) {
- mBGLView->DrawBitmap(mBitmap, BPoint(0, 0));
- }
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->SwapBuffers();
+
+ if (vSync) {
+ BScreen screen(Window());
+ screen.WaitForRetrace();
+ }
}
-void AuxInfo::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const
+#if 0
+void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height)
{
- if (mBitmap) {
- // Source bitmap and view's bitmap are same size.
- // Source and dest rectangle are the same.
- // Note (x,y) = (0,0) is the lower-left corner, have to flip Y
- BRect srcAndDest;
- srcAndDest.left = x;
- srcAndDest.right = x + width - 1;
- srcAndDest.bottom = mBottom - y;
- srcAndDest.top = srcAndDest.bottom - height + 1;
- mBGLView->DrawBitmap(mBitmap, srcAndDest, srcAndDest);
- }
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->CopySubBuffer(x, y, width, height);
}
+#endif
+BView * BGLView::EmbeddedView()
+{
+ return NULL;
+}
-void AuxInfo::UpdateState( GLcontext *ctx )
+status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+ if (! dest || ! dest->Bounds().IsValid())
+ return B_BAD_VALUE;
- assert(aux->mContext == ctx );
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ return md->CopyPixelsOut(source, dest);
+}
- ctx->Driver.UpdateState = AuxInfo::UpdateState;
- ctx->Driver.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;
+status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
+{
+ if (! source || ! source->Bounds().IsValid())
+ return B_BAD_VALUE;
- if (ctx->Color.DrawBuffer == GL_FRONT) {
- /* read/write front buffer */
- ctx->Driver.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;
- }
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ return md->CopyPixelsIn(source, dest);
}
-void AuxInfo::ClearIndex(GLcontext *ctx, GLuint index)
+void BGLView::ErrorCallback(unsigned long errorCode) // Mesa's GLenum is not ulong but uint!
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- aux->mClearIndex = index;
+ char msg[32];
+ sprintf(msg, "GL: Error code $%04lx.", errorCode);
+ // debugger(msg);
+ fprintf(stderr, "%s\n", msg);
+ return;
}
-
-void AuxInfo::ClearColor(GLcontext *ctx, GLubyte r, GLubyte g,
- GLubyte b, GLubyte a)
+void BGLView::Draw(BRect updateRect)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- aux->mClearColor[BE_RCOMP] = r;
- aux->mClearColor[BE_GCOMP] = g;
- aux->mClearColor[BE_BCOMP] = b;
- aux->mClearColor[BE_ACOMP] = a;
- assert(aux->mBGLView);
+ // printf("BGLView::Draw()\n");
+ MesaDriver * md = (MesaDriver *) m_gc;
+ assert(md);
+ md->Draw(updateRect);
}
-
-GLbitfield AuxInfo::ClearFront(GLcontext *ctx, GLbitfield mask,
- GLboolean all, GLint x, GLint y,
- GLint width, GLint height)
+void BGLView::AttachedToWindow()
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
- assert(bglview);
+ BView::AttachedToWindow();
- 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);
- }
+ // don't paint window background white when resized
+ SetViewColor(B_TRANSPARENT_32_BIT);
+}
- // 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);
+void BGLView::AllAttached()
+{
+ BView::AllAttached();
+// printf("BGLView AllAttached\n");
}
+void BGLView::DetachedFromWindow()
+{
+ BView::DetachedFromWindow();
+}
-GLbitfield AuxInfo::ClearBack(GLcontext *ctx, GLbitfield mask,
- GLboolean all, GLint x, GLint y,
- GLint width, GLint height)
+void BGLView::AllDetached()
{
- 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;
+ BView::AllDetached();
+// printf("BGLView AllDetached");
+}
- 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;
- }
- }
+void BGLView::FrameResized(float width, float height)
+{
+ return BView::FrameResized(width, height);
+}
- return mask & (~GL_COLOR_BUFFER_BIT);
+status_t BGLView::Perform(perform_code d, void *arg)
+{
+ return BView::Perform(d, arg);
}
-void AuxInfo::Index(GLcontext *ctx, GLuint index)
+status_t BGLView::Archive(BMessage *data, bool deep) const
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
- assert(bglview);
- aux->mIndex = index;
+ return BView::Archive(data, deep);
}
+void BGLView::MessageReceived(BMessage *msg)
+{
+ BView::MessageReceived(msg);
+}
-void AuxInfo::Color(GLcontext *ctx, GLubyte r, GLubyte g,
- GLubyte b, GLubyte a)
+void BGLView::SetResizingMode(uint32 mode)
{
- 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);
+ BView::SetResizingMode(mode);
}
-GLboolean AuxInfo::SetBuffer(GLcontext *ctx, GLenum buffer)
+void BGLView::Show()
{
- if (buffer == GL_FRONT_LEFT)
- return GL_TRUE;
- else if (buffer == GL_BACK_LEFT)
- return GL_TRUE;
- else
- return GL_FALSE;
+ BView::Show();
}
-void AuxInfo::GetBufferSize(GLcontext *ctx, GLuint *width,
- GLuint *height)
+void BGLView::Hide()
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
- assert(bglview);
- BRect b = bglview->Bounds();
- *width = (GLuint) (b.right - b.left + 1);
- *height = (GLuint) (b.bottom - b.top + 1);
- aux->mBottom = (GLint) b.bottom;
+ BView::Hide();
+}
- 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;
- }
+BHandler *BGLView::ResolveSpecifier(BMessage *msg, int32 index,
+ BMessage *specifier, int32 form,
+ const char *property)
+{
+ return BView::ResolveSpecifier(msg, index, specifier, form, property);
+}
- aux->mWidth = *width;
- aux->mHeight = *height;
+status_t BGLView::GetSupportedSuites(BMessage *data)
+{
+ return BView::GetSupportedSuites(data);
}
+void BGLView::DirectConnected( direct_buffer_info *info )
+{
+#if 0
+ if (! m_direct_connected && m_direct_connection_disabled)
+ return;
+
+ direct_info_locker->Lock();
+ switch(info->buffer_state & B_DIRECT_MODE_MASK) {
+ case B_DIRECT_START:
+ m_direct_connected = true;
+ case B_DIRECT_MODIFY:
+ // Get clipping information
+ if (m_clip_list)
+ free(m_clip_list);
+ m_clip_list_count = info->clip_list_count;
+ m_clip_list = (clipping_rect *) malloc(m_clip_list_count*sizeof(clipping_rect));
+ if (m_clip_list) {
+ memcpy(m_clip_list, info->clip_list, m_clip_list_count*sizeof(clipping_rect));
+ fBits = (uint8 *) info->bits;
+ fRowBytes = info->bytes_per_row;
+ fFormat = info->pixel_format;
+ fBounds = info->window_bounds;
+ fDirty = true;
+ }
+ break;
+ case B_DIRECT_STOP:
+ fConnected = false;
+ break;
+ }
+ direct_info_locker->Unlock();
+#endif
+}
-const GLubyte *AuxInfo::GetString(GLcontext *ctx, GLenum name)
+void BGLView::EnableDirectMode( bool enabled )
{
- switch (name) {
- case GL_RENDERER:
- return (const GLubyte *) "Mesa BeOS";
- default:
- // Let core library handle all other cases
- return NULL;
- }
+ // TODO
}
-// 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)
+//---- virtual reserved methods ----------
+
+void BGLView::_ReservedGLView1() {}
+void BGLView::_ReservedGLView2() {}
+void BGLView::_ReservedGLView3() {}
+void BGLView::_ReservedGLView4() {}
+void BGLView::_ReservedGLView5() {}
+void BGLView::_ReservedGLView6() {}
+void BGLView::_ReservedGLView7() {}
+void BGLView::_ReservedGLView8() {}
+
+#if 0
+// Not implemented!!!
+
+BGLView::BGLView(const BGLView &v)
+ : BView(v)
{
- // XXX There's got to be a better way!
- BPoint p(x, y), q(x+1, y);
- bglview->StrokeLine(p, q);
+ // XXX not sure how this should work
+ printf("Warning BGLView::copy constructor not implemented\n");
}
-
-void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
- GLint x, GLint y,
- CONST GLubyte rgba[][4],
- const GLubyte mask[])
+BGLView &BGLView::operator=(const BGLView &v)
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
- assert(bglview);
- int flippedY = aux->mBottom - y;
- if (mask) {
- for (GLuint i = 0; i < n; i++) {
- if (mask[i]) {
- bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], 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);
- }
- }
+ printf("Warning BGLView::operator= not implemented\n");
+ return *this;
}
+#endif
-void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
- GLint x, GLint y,
- CONST GLubyte rgba[][3],
- const GLubyte mask[])
+void BGLView::dither_front()
{
- AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
- BGLView *bglview = aux->mBGLView;
- assert(bglview);
- int flippedY = aux->mBottom - y;
- if (mask) {
+ // 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);
+
+ delete m_bitmap;
+}
+
+
+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 );
+ assert(tnl);
+ assert(swdd);
+
+ // Use default TCL pipeline
+ tnl->Driver.RunPipeline = _tnl_run_pipeline;
+
+ swdd->SetBuffer = this->SetBuffer;
+}
+
+
+void MesaDriver::LockGL()
+{
+ m_bglview->LockLooper();
+
+ UpdateState(m_glcontext, 0);
+ _mesa_make_current(m_glcontext, m_glframebuffer);
+}
+
+
+void MesaDriver::UnlockGL()
+{
+ if (m_bglview->Looper()->IsLocked())
+ m_bglview->UnlockLooper();
+ // Could call _mesa_make_current(NULL, NULL) but it would just
+ // hinder performance
+}
+
+
+void MesaDriver::SwapBuffers() const
+{
+ _mesa_notifySwapBuffers(m_glcontext);
+
+ if (m_bitmap) {
+ m_bglview->LockLooper();
+ m_bglview->DrawBitmap(m_bitmap);
+ 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 = m_bottom - y;
+ srcAndDest.top = srcAndDest.bottom - height + 1;
+ m_bglview->DrawBitmap(m_bitmap, srcAndDest, srcAndDest);
+ }
+}
+
+status_t MesaDriver::CopyPixelsOut(BPoint location, BBitmap *bitmap)
+{
+ color_space scs = m_bitmap->ColorSpace();
+ color_space dcs = bitmap->ColorSpace();
+
+ if (scs != dcs && (scs != B_RGBA32 || dcs != B_RGB32)) {
+ printf("CopyPixelsOut(): incompatible color space: %s != %s\n",
+ color_space_name(scs),
+ color_space_name(dcs));
+ return B_BAD_TYPE;
+ }
+
+ // debugger("CopyPixelsOut()");
+
+ BRect sr = m_bitmap->Bounds();
+ BRect dr = bitmap->Bounds();
+
+ sr = sr & dr.OffsetBySelf(location);
+ dr = sr.OffsetByCopy(-location.x, -location.y);
+
+ uint8 *ps = (uint8 *) m_bitmap->Bits();
+ uint8 *pd = (uint8 *) bitmap->Bits();
+ uint32 *s, *d;
+ uint32 y;
+ for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
+ s = (uint32 *) (ps + y * m_bitmap->BytesPerRow());
+ s += (uint32) sr.left;
+
+ d = (uint32 *) (pd + (y + (uint32) (dr.top - sr.top)) * bitmap->BytesPerRow());
+ d += (uint32) dr.left;
+
+ memcpy(d, s, dr.IntegerWidth() * 4);
+ }
+ return B_OK;
+}
+
+status_t MesaDriver::CopyPixelsIn(BBitmap *bitmap, BPoint location)
+{
+ color_space scs = bitmap->ColorSpace();
+ color_space dcs = m_bitmap->ColorSpace();
+
+ if (scs != dcs && (dcs != B_RGBA32 || scs != B_RGB32)) {
+ printf("CopyPixelsIn(): incompatible color space: %s != %s\n",
+ color_space_name(scs),
+ color_space_name(dcs));
+ return B_BAD_TYPE;
+ }
+
+ // debugger("CopyPixelsIn()");
+
+ BRect sr = bitmap->Bounds();
+ BRect dr = m_bitmap->Bounds();
+
+ sr = sr & dr.OffsetBySelf(location);
+ dr = sr.OffsetByCopy(-location.x, -location.y);
+
+ uint8 *ps = (uint8 *) bitmap->Bits();
+ uint8 *pd = (uint8 *) m_bitmap->Bits();
+ uint32 *s, *d;
+ uint32 y;
+ for (y = (uint32) sr.top; y <= (uint32) sr.bottom; y++) {
+ s = (uint32 *) (ps + y * bitmap->BytesPerRow());
+ s += (uint32) sr.left;
+
+ d = (uint32 *) (pd + (y + (uint32) (dr.top - sr.top)) * m_bitmap->BytesPerRow());
+ d += (uint32) dr.left;
+
+ memcpy(d, s, dr.IntegerWidth() * 4);
+ }
+ return B_OK;
+}
+
+
+void MesaDriver::Draw(BRect updateRect) const
+{
+ if (m_bitmap)
+ m_bglview->DrawBitmap(m_bitmap, updateRect, updateRect);
+}
+
+
+void MesaDriver::Error(GLcontext *ctx)
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ if (md && md->m_bglview)
+ md->m_bglview->ErrorCallback((unsigned long) ctx->ErrorValue);
+}
+
+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[0] == GL_FRONT) {
+ /* read/write front buffer */
+ swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanFront;
+ swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanFront;
+ swdd->WriteRGBAPixels = MesaDriver::WriteRGBAPixelsFront;
+ swdd->WriteMonoRGBASpan = MesaDriver::WriteMonoRGBASpanFront;
+ swdd->WriteMonoRGBAPixels = MesaDriver::WriteMonoRGBAPixelsFront;
+ swdd->WriteCI32Span = MesaDriver::WriteCI32SpanFront;
+ swdd->WriteCI8Span = MesaDriver::WriteCI8SpanFront;
+ swdd->WriteMonoCISpan = MesaDriver::WriteMonoCISpanFront;
+ swdd->WriteCI32Pixels = MesaDriver::WriteCI32PixelsFront;
+ swdd->WriteMonoCIPixels = MesaDriver::WriteMonoCIPixelsFront;
+ swdd->ReadRGBASpan = MesaDriver::ReadRGBASpanFront;
+ swdd->ReadRGBAPixels = MesaDriver::ReadRGBAPixelsFront;
+ swdd->ReadCI32Span = MesaDriver::ReadCI32SpanFront;
+ swdd->ReadCI32Pixels = MesaDriver::ReadCI32PixelsFront;
+ }
+ else {
+ /* read/write back buffer */
+ swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanBack;
+ swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanBack;
+ swdd->WriteRGBAPixels = MesaDriver::WriteRGBAPixelsBack;
+ swdd->WriteMonoRGBASpan = MesaDriver::WriteMonoRGBASpanBack;
+ swdd->WriteMonoRGBAPixels = MesaDriver::WriteMonoRGBAPixelsBack;
+ swdd->WriteCI32Span = MesaDriver::WriteCI32SpanBack;
+ swdd->WriteCI8Span = MesaDriver::WriteCI8SpanBack;
+ swdd->WriteMonoCISpan = MesaDriver::WriteMonoCISpanBack;
+ swdd->WriteCI32Pixels = MesaDriver::WriteCI32PixelsBack;
+ swdd->WriteMonoCIPixels = MesaDriver::WriteMonoCIPixelsBack;
+ swdd->ReadRGBASpan = MesaDriver::ReadRGBASpanBack;
+ swdd->ReadRGBAPixels = MesaDriver::ReadRGBAPixelsBack;
+ swdd->ReadCI32Span = MesaDriver::ReadCI32SpanBack;
+ swdd->ReadCI32Pixels = MesaDriver::ReadCI32PixelsBack;
+ }
+}
+
+
+void MesaDriver::ClearIndex(GLcontext *ctx, GLuint index)
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ md->m_clear_index = index;
+}
+
+
+void MesaDriver::ClearColor(GLcontext *ctx, const GLfloat color[4])
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_RCOMP], color[0]);
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_GCOMP], color[1]);
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_BCOMP], color[2]);
+ CLAMPED_FLOAT_TO_CHAN(md->m_clear_color[BE_ACOMP], color[3]);
+ assert(md->m_bglview);
+}
+
+
+void 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);
+ if (mask & DD_BACK_LEFT_BIT)
+ ClearBack(ctx, all, x, y, width, height);
+
+ mask &= ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT);
+ if (mask)
+ _swrast_Clear( ctx, mask, all, x, y, width, height );
+
+ return;
+}
+
+
+void MesaDriver::ClearFront(GLcontext *ctx,
+ GLboolean all, GLint x, GLint y,
+ GLint width, GLint height)
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
+ assert(bglview);
+
+ bglview->SetHighColor(md->m_clear_color[BE_RCOMP],
+ md->m_clear_color[BE_GCOMP],
+ md->m_clear_color[BE_BCOMP],
+ md->m_clear_color[BE_ACOMP]);
+ bglview->SetLowColor(md->m_clear_color[BE_RCOMP],
+ md->m_clear_color[BE_GCOMP],
+ md->m_clear_color[BE_BCOMP],
+ md->m_clear_color[BE_ACOMP]);
+ if (all) {
+ BRect b = bglview->Bounds();
+ bglview->FillRect(b);
+ }
+ else {
+ // XXX untested
+ BRect b;
+ b.left = x;
+ b.right = x + width;
+ b.bottom = md->m_height - y - 1;
+ b.top = b.bottom - height;
+ bglview->FillRect(b);
+ }
+
+ // restore drawing color
+#if 0
+ bglview->SetHighColor(md->mColor[BE_RCOMP],
+ md->mColor[BE_GCOMP],
+ md->mColor[BE_BCOMP],
+ md->mColor[BE_ACOMP]);
+ bglview->SetLowColor(md->mColor[BE_RCOMP],
+ md->mColor[BE_GCOMP],
+ md->mColor[BE_BCOMP],
+ md->mColor[BE_ACOMP]);
+#endif
+}
+
+
+void MesaDriver::ClearBack(GLcontext *ctx,
+ GLboolean all, GLint x, GLint y,
+ GLint width, GLint height)
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
+ assert(bglview);
+ BBitmap *bitmap = md->m_bitmap;
+ assert(bitmap);
+ GLuint *start = (GLuint *) bitmap->Bits();
+ const GLuint *clearPixelPtr = (const GLuint *) md->m_clear_color;
+ const GLuint clearPixel = B_LENDIAN_TO_HOST_INT32(*clearPixelPtr);
+
+ if (all) {
+ const int numPixels = md->m_width * md->m_height;
+ if (clearPixel == 0) {
+ memset(start, 0, numPixels * 4);
+ }
+ else {
+ for (int i = 0; i < numPixels; i++) {
+ start[i] = clearPixel;
+ }
+ }
+ }
+ else {
+ // XXX untested
+ start += y * md->m_width + x;
+ for (int i = 0; i < height; i++) {
+ for (int j = 0; j < width; j++) {
+ start[j] = clearPixel;
+ }
+ start += md->m_width;
+ }
+ }
+}
+
+
+void MesaDriver::SetBuffer(GLcontext *ctx, GLframebuffer *buffer,
+ GLenum mode)
+{
+ /* TODO */
+ (void) ctx;
+ (void) buffer;
+ (void) mode;
+}
+
+void MesaDriver::GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
+ GLuint *height)
+{
+ 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.IntegerWidth() + 1; // (b.right - b.left + 1);
+ *height = (GLuint) b.IntegerHeight() + 1; // (b.bottom - b.top + 1);
+ md->m_bottom = (GLint) b.bottom;
+
+ if (ctx->Visual.doubleBufferMode) {
+ if (*width != md->m_width || *height != md->m_height) {
+ // allocate new size of back buffer bitmap
+ if (md->m_bitmap)
+ delete md->m_bitmap;
+ BRect rect(0.0, 0.0, *width - 1, *height - 1);
+ md->m_bitmap = new BBitmap(rect, B_RGBA32);
+ }
+ }
+ else
+ {
+ md->m_bitmap = NULL;
+ }
+
+ md->m_width = *width;
+ md->m_height = *height;
+}
+
+
+void MesaDriver::Viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ /* poll for window size change and realloc software Z/stencil/etc if needed */
+ _mesa_ResizeBuffersMESA();
+}
+
+
+const GLubyte *MesaDriver::GetString(GLcontext *ctx, GLenum name)
+{
+ switch (name) {
+ case GL_RENDERER:
+ return (const GLubyte *) "Mesa " MESA_VERSION_STRING " powered BGLView (software)";
+ default:
+ // Let core library handle all other cases
+ return NULL;
+ }
+}
+
+
+// Plot a pixel. (0,0) is upper-left corner
+// This is only used when drawing to the front buffer.
+inline void Plot(BGLView *bglview, int x, int y)
+{
+ // XXX There's got to be a better way!
+ BPoint p(x, y), q(x+1, y);
+ bglview->StrokeLine(p, q);
+}
+
+
+void MesaDriver::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+ GLint x, GLint y,
+ CONST GLubyte rgba[][4],
+ const GLubyte mask[])
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
+ assert(bglview);
+ int flippedY = md->m_bottom - y;
+ if (mask) {
+ for (GLuint i = 0; i < n; i++) {
+ if (mask[i]) {
+ bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], rgba[i][3]);
+ Plot(bglview, x++, flippedY);
+ }
+ }
+ }
+ else {
+ for (GLuint i = 0; i < n; i++) {
+ bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2], rgba[i][3]);
+ Plot(bglview, x++, flippedY);
+ }
+ }
+}
+
+void MesaDriver::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+ GLint x, GLint y,
+ CONST GLubyte rgba[][3],
+ const GLubyte mask[])
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BGLView *bglview = md->m_bglview;
+ assert(bglview);
+ int flippedY = md->m_bottom - y;
+ if (mask) {
for (GLuint i = 0; i < n; i++) {
if (mask[i]) {
bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]);
}
}
-void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
- GLint x, GLint y, const GLubyte mask[])
+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++) {
if (mask[i]) {
}
}
-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
+ printf("WriteCI32SpanFront() not implemented yet!\n");
+ // TODO
}
-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
+ printf("WriteCI8SpanFront() not implemented yet!\n");
+ // TODO
}
-void AuxInfo::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
- GLint x, GLint y, const GLubyte mask[] )
+void MesaDriver::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
+ GLint x, GLint y,
+ GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCISpanFront() not implemented yet!\n");
+ // TODO
}
-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
+ printf("WriteCI32PixelsFront() not implemented yet!\n");
+ // TODO
}
-void AuxInfo::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
- const GLubyte mask[] )
+ GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCIPixelsFront() not implemented yet!\n");
+ // TODO
}
-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");
+ // TODO
}
-void AuxInfo::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
GLint x, GLint y, GLubyte rgba[][4] )
{
- // XXX to do
+ printf("ReadRGBASpanFront() not implemented yet!\n");
+ // TODO
}
-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[] )
{
- // XXX to do
+ printf("ReadCI32PixelsFront() not implemented yet!\n");
+ // TODO
}
-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[] )
{
- // XXX to do
+ printf("ReadRGBAPixelsFront() not implemented yet!\n");
+ // TODO
}
-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;
+
+ 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;
+
+ 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,
- GLint x, GLint y, const GLubyte mask[])
+
+
+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;
- 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;
- }
- }
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ assert(bitmap);
+
+ int row = md->m_bottom - y;
+ uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4;
+ uint32 * pixel = (uint32 *) ptr;
+ uint32 pixel_color = PACK_B_RGBA32(color);
+
+ if (mask) {
+ while(n--) {
+ if (*mask++)
+ *pixel = pixel_color;
+ pixel++;
+ };
+ } else {
+ while(n--) {
+ *pixel++ = pixel_color;
+ };
+ };
}
-void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx,
+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;
+
+ 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];
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,
- 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);
+void MesaDriver::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+ const GLint x[], const GLint y[],
+ const GLchan color[4],
+ const GLubyte mask[])
+{
+ MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+ BBitmap *bitmap = md->m_bitmap;
+
+ 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
+ printf("WriteCI32SpanBack() not implemented yet!\n");
+ // TODO
}
-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
+ printf("WriteCI8SpanBack() not implemented yet!\n");
+ // TODO
}
-void AuxInfo::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
- GLint x, GLint y, const GLubyte mask[] )
+void MesaDriver::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
+ GLint x, GLint y,
+ GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCISpanBack() not implemented yet!\n");
+ // TODO
}
-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
+ printf("WriteCI32PixelsBack() not implemented yet!\n");
+ // TODO
}
-void AuxInfo::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
const GLint x[], const GLint y[],
- const GLubyte mask[] )
+ GLuint colorIndex, const GLubyte mask[] )
{
- // XXX to do
+ printf("WriteMonoCIPixelsBack() not implemented yet!\n");
+ // TODO
}
-void AuxInfo::ReadCI32SpanBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanBack( const GLcontext *ctx,
GLuint n, GLint x, GLint y, GLuint index[] )
{
- // XXX to do
+ printf("ReadCI32SpanBack() not implemented yet!\n");
+ // TODO
}
-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];
}
-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[] )
{
- // XXX to do
+ printf("ReadCI32PixelsBack() not implemented yet!\n");
+ // TODO
}
-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 = 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
-}
+ };
+ };
+}
+
+const char * color_space_name(color_space space)
+{
+#define C2N(a) case a: return #a
+
+ switch (space) {
+ C2N(B_RGB24);
+ C2N(B_RGB32);
+ C2N(B_RGBA32);
+ C2N(B_RGB32_BIG);
+ C2N(B_RGBA32_BIG);
+ C2N(B_GRAY8);
+ C2N(B_GRAY1);
+ C2N(B_RGB16);
+ C2N(B_RGB15);
+ C2N(B_RGBA15);
+ C2N(B_CMAP8);
+ default:
+ return "Unknown!";
+ };
+
+#undef C2N
+};
-bool BGLView::validateView()
-{
- // no-op
- return true;
-}
projects / mesa.git / blobdiff