/**
* Create a new renderbuffer object.
* Typically called via glBindRenderbufferEXT().
*/
static struct gl_renderbuffer *
intel_new_renderbuffer(struct gl_context * ctx, GLuint name)
{
struct intel_renderbuffer *irb;
struct gl_renderbuffer *rb;
irb = CALLOC_STRUCT(intel_renderbuffer);
if (!irb) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
return NULL;
}
rb = &irb->Base.Base;
_mesa_init_renderbuffer(rb, name);
rb->ClassID = INTEL_RB_CLASS;
/* intel-specific methods */
rb->Delete = intel_delete_renderbuffer;
rb->AllocStorage = intel_alloc_renderbuffer_storage;
/* span routines set in alloc_storage function */
return rb;
}
/**
* This function creates a renderbuffer object which wraps a texture image.
* The new renderbuffer is plugged into the given attachment point.
* This allows rendering into the texture as if it were a renderbuffer.
*/
static void
wrap_texture(struct gl_context *ctx, struct gl_renderbuffer_attachment *att)
{
struct gl_renderbuffer *rb;
const GLuint name = 0;
ASSERT(att->Type == GL_TEXTURE);
ASSERT(att->Renderbuffer == NULL);
rb = ctx->Driver.NewRenderbuffer(ctx, name);
if (!rb) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "wrap_texture");
return;
}
/* init base gl_renderbuffer fields */
_mesa_init_renderbuffer(rb, name);
/* plug in our texture_renderbuffer-specific functions */
rb->Delete = delete_texture_wrapper;
rb->AllocStorage = NULL; /* illegal! */
/* update attachment point */
_mesa_reference_renderbuffer(&att->Renderbuffer, rb);
}
/**
* Allocate a renderbuffer for a an on-screen window (not a user-created
* renderbuffer). The window system code determines the format.
*/
struct gl_renderbuffer *
st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
{
struct st_renderbuffer *strb;
strb = ST_CALLOC_STRUCT(st_renderbuffer);
if (!strb) {
_mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");
return NULL;
}
_mesa_init_renderbuffer(&strb->Base, 0);
strb->Base.ClassID = 0x4242; /* just a unique value */
strb->Base.NumSamples = samples;
strb->Base.Format = st_pipe_format_to_mesa_format(format);
strb->Base._BaseFormat = _mesa_get_format_base_format(strb->Base.Format);
strb->software = sw;
switch (format) {
case PIPE_FORMAT_R8G8B8A8_UNORM:
case PIPE_FORMAT_B8G8R8A8_UNORM:
case PIPE_FORMAT_A8R8G8B8_UNORM:
strb->Base.InternalFormat = GL_RGBA8;
break;
case PIPE_FORMAT_R8G8B8X8_UNORM:
case PIPE_FORMAT_B8G8R8X8_UNORM:
case PIPE_FORMAT_X8R8G8B8_UNORM:
strb->Base.InternalFormat = GL_RGB8;
break;
case PIPE_FORMAT_R8G8B8A8_SRGB:
case PIPE_FORMAT_B8G8R8A8_SRGB:
case PIPE_FORMAT_A8R8G8B8_SRGB:
strb->Base.InternalFormat = GL_SRGB8_ALPHA8;
break;
case PIPE_FORMAT_R8G8B8X8_SRGB:
case PIPE_FORMAT_B8G8R8X8_SRGB:
case PIPE_FORMAT_X8R8G8B8_SRGB:
strb->Base.InternalFormat = GL_SRGB8;
break;
case PIPE_FORMAT_B5G5R5A1_UNORM:
strb->Base.InternalFormat = GL_RGB5_A1;
break;
case PIPE_FORMAT_B4G4R4A4_UNORM:
strb->Base.InternalFormat = GL_RGBA4;
break;
case PIPE_FORMAT_B5G6R5_UNORM:
strb->Base.InternalFormat = GL_RGB565;
break;
case PIPE_FORMAT_Z16_UNORM:
strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;
break;
case PIPE_FORMAT_Z32_UNORM:
strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
break;
case PIPE_FORMAT_Z24_UNORM_S8_UINT:
case PIPE_FORMAT_S8_UINT_Z24_UNORM:
strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
break;
case PIPE_FORMAT_Z24X8_UNORM:
case PIPE_FORMAT_X8Z24_UNORM:
strb->Base.InternalFormat = GL_DEPTH_COMPONENT24;
break;
case PIPE_FORMAT_S8_UINT:
strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
break;
case PIPE_FORMAT_R16G16B16A16_SNORM:
/* accum buffer */
strb->Base.InternalFormat = GL_RGBA16_SNORM;
break;
case PIPE_FORMAT_R16G16B16A16_UNORM:
strb->Base.InternalFormat = GL_RGBA16;
break;
case PIPE_FORMAT_R8_UNORM:
strb->Base.InternalFormat = GL_R8;
break;
case PIPE_FORMAT_R8G8_UNORM:
strb->Base.InternalFormat = GL_RG8;
break;
case PIPE_FORMAT_R16_UNORM:
strb->Base.InternalFormat = GL_R16;
break;
case PIPE_FORMAT_R16G16_UNORM:
strb->Base.InternalFormat = GL_RG16;
break;
case PIPE_FORMAT_R32G32B32A32_FLOAT:
strb->Base.InternalFormat = GL_RGBA32F;
break;
case PIPE_FORMAT_R16G16B16A16_FLOAT:
strb->Base.InternalFormat = GL_RGBA16F;
break;
default:
_mesa_problem(NULL,
"Unexpected format %s in st_new_renderbuffer_fb",
util_format_name(format));
free(strb);
return NULL;
}
/* st-specific methods */
strb->Base.Delete = st_renderbuffer_delete;
strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
/* surface is allocated in st_renderbuffer_alloc_storage() */
strb->surface = NULL;
return &strb->Base;
}
/**
* Allocate a new driRenderbuffer object.
* Individual drivers are free to implement different versions of
* this function.
*
* At this time, this function can only be used for window-system
* renderbuffers, not user-created RBOs.
*
* \param format Either GL_RGBA, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24,
* GL_DEPTH_COMPONENT32, or GL_STENCIL_INDEX8_EXT (for now).
* \param addr address in main memory of the buffer. Probably a memory
* mapped region.
* \param cpp chars or bytes per pixel
* \param offset start of renderbuffer with respect to start of framebuffer
* \param pitch pixels per row
*/
driRenderbuffer *
driNewRenderbuffer(gl_format format, GLvoid *addr,
GLint cpp, GLint offset, GLint pitch,
__DRIdrawablePrivate *dPriv)
{
driRenderbuffer *drb;
assert(format == GL_RGBA ||
format == GL_RGB5 ||
format == GL_RGBA8 ||
format == GL_DEPTH_COMPONENT16 ||
format == GL_DEPTH_COMPONENT24 ||
format == GL_DEPTH_COMPONENT32 ||
format == GL_STENCIL_INDEX8_EXT);
assert(cpp > 0);
assert(pitch > 0);
drb = _mesa_calloc(sizeof(driRenderbuffer));
if (drb) {
const GLuint name = 0;
_mesa_init_renderbuffer(&drb->Base, name);
/* Make sure we're using a null-valued GetPointer routine */
assert(drb->Base.GetPointer(NULL, &drb->Base, 0, 0) == NULL);
switch (format) {
case MESA_FORMAT_ARGB8888:
if (cpp == 2) {
/* override format */
format = MESA_FORMAT_RGB565;
}
drb->Base.DataType = GL_UNSIGNED_BYTE;
break;
case MESA_FORMAT_Z16:
/* Depth */
/* we always Get/Put 32-bit Z values */
drb->Base.DataType = GL_UNSIGNED_INT;
assert(cpp == 2);
break;
case MESA_FORMAT_Z32:
/* Depth */
/* we always Get/Put 32-bit Z values */
drb->Base.DataType = GL_UNSIGNED_INT;
assert(cpp == 4);
break;
case MESA_FORMAT_Z24_S8:
drb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
assert(cpp == 4);
break;
case MESA_FORMAT_S8_Z24:
drb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
assert(cpp == 4);
break;
case MESA_FORMAT_S8:
/* Stencil */
drb->Base.DataType = GL_UNSIGNED_BYTE;
break;
default:
_mesa_problem(NULL, "Bad format 0x%x in driNewRenderbuffer", format);
return NULL;
}
drb->Base.Format = format;
drb->Base.InternalFormat =
drb->Base._BaseFormat = _mesa_get_format_base_format(format);
drb->Base.AllocStorage = driRenderbufferStorage;
drb->Base.Delete = driDeleteRenderbuffer;
drb->Base.Data = addr;
/* DRI renderbuffer-specific fields: */
drb->dPriv = dPriv;
drb->offset = offset;
drb->pitch = pitch;
drb->cpp = cpp;
/* may be changed if page flipping is active: */
drb->flippedOffset = offset;
drb->flippedPitch = pitch;
drb->flippedData = addr;
}
return drb;
}
static struct swrast_renderbuffer *
swrast_new_renderbuffer(const struct gl_config *visual, __DRIdrawable *dPriv,
GLboolean front)
{
struct swrast_renderbuffer *xrb = calloc(1, sizeof *xrb);
GLuint pixel_format;
TRACE;
if (!xrb)
return NULL;
_mesa_init_renderbuffer(&xrb->Base, 0);
pixel_format = choose_pixel_format(visual);
xrb->dPriv = dPriv;
xrb->Base.Delete = swrast_delete_renderbuffer;
if (front) {
xrb->Base.AllocStorage = swrast_alloc_front_storage;
swrast_set_span_funcs_front(xrb, pixel_format);
}
else {
xrb->Base.AllocStorage = swrast_alloc_back_storage;
swrast_set_span_funcs_back(xrb, pixel_format);
}
switch (pixel_format) {
case PF_A8R8G8B8:
xrb->Base.Format = MESA_FORMAT_ARGB8888;
xrb->Base.InternalFormat = GL_RGBA;
xrb->Base._BaseFormat = GL_RGBA;
xrb->Base.DataType = GL_UNSIGNED_BYTE;
xrb->bpp = 32;
break;
case PF_X8R8G8B8:
xrb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX */
xrb->Base.InternalFormat = GL_RGB;
xrb->Base._BaseFormat = GL_RGB;
xrb->Base.DataType = GL_UNSIGNED_BYTE;
xrb->bpp = 32;
break;
case PF_R5G6B5:
xrb->Base.Format = MESA_FORMAT_RGB565;
xrb->Base.InternalFormat = GL_RGB;
xrb->Base._BaseFormat = GL_RGB;
xrb->Base.DataType = GL_UNSIGNED_BYTE;
xrb->bpp = 16;
break;
case PF_R3G3B2:
xrb->Base.Format = MESA_FORMAT_RGB332;
xrb->Base.InternalFormat = GL_RGB;
xrb->Base._BaseFormat = GL_RGB;
xrb->Base.DataType = GL_UNSIGNED_BYTE;
xrb->bpp = 8;
break;
default:
return NULL;
}
return xrb;
}
/**
* Create a renderbuffer for a window's color, depth and/or stencil buffer.
* Not used for user-created renderbuffers.
*/
struct radeon_renderbuffer *
radeon_create_renderbuffer(gl_format format, __DRIdrawable *driDrawPriv)
{
struct radeon_renderbuffer *rrb;
rrb = CALLOC_STRUCT(radeon_renderbuffer);
radeon_print(RADEON_TEXTURE, RADEON_TRACE,
"%s( rrb %p ) \n",
__func__, rrb);
if (!rrb)
return NULL;
_mesa_init_renderbuffer(&rrb->base, 0);
rrb->base.ClassID = RADEON_RB_CLASS;
rrb->base.Format = format;
switch (format) {
case MESA_FORMAT_RGB565:
assert(_mesa_little_endian());
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_RGB;
break;
case MESA_FORMAT_RGB565_REV:
assert(!_mesa_little_endian());
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_RGB;
break;
case MESA_FORMAT_XRGB8888:
assert(_mesa_little_endian());
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_RGB;
break;
case MESA_FORMAT_XRGB8888_REV:
assert(!_mesa_little_endian());
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_RGB;
break;
case MESA_FORMAT_ARGB8888:
assert(_mesa_little_endian());
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_RGBA;
break;
case MESA_FORMAT_ARGB8888_REV:
assert(!_mesa_little_endian());
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_RGBA;
break;
case MESA_FORMAT_S8:
rrb->base.DataType = GL_UNSIGNED_BYTE;
rrb->base._BaseFormat = GL_STENCIL_INDEX;
break;
case MESA_FORMAT_Z16:
rrb->base.DataType = GL_UNSIGNED_SHORT;
rrb->base._BaseFormat = GL_DEPTH_COMPONENT;
break;
case MESA_FORMAT_X8_Z24:
rrb->base.DataType = GL_UNSIGNED_INT;
rrb->base._BaseFormat = GL_DEPTH_COMPONENT;
break;
case MESA_FORMAT_S8_Z24:
rrb->base.DataType = GL_UNSIGNED_INT_24_8_EXT;
rrb->base._BaseFormat = GL_DEPTH_STENCIL;
break;
default:
fprintf(stderr, "%s: Unknown format %s\n",
__FUNCTION__, _mesa_get_format_name(format));
_mesa_delete_renderbuffer(&rrb->base);
return NULL;
}
rrb->dPriv = driDrawPriv;
rrb->base.InternalFormat = _mesa_get_format_base_format(format);
rrb->base.Delete = radeon_delete_renderbuffer;
rrb->base.AllocStorage = radeon_alloc_window_storage;
rrb->base.GetPointer = radeon_get_pointer;
rrb->bo = NULL;
return rrb;
}
/**
* Create a new intel_renderbuffer which corresponds to an on-screen window,
* not a user-created renderbuffer.
*/
struct intel_renderbuffer *
intel_create_renderbuffer(GLenum intFormat)
{
GET_CURRENT_CONTEXT(ctx);
struct intel_renderbuffer *irb;
const GLuint name = 0;
irb = CALLOC_STRUCT(intel_renderbuffer);
if (!irb) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
return NULL;
}
_mesa_init_renderbuffer(&irb->Base, name);
irb->Base.ClassID = INTEL_RB_CLASS;
switch (intFormat) {
case GL_RGB5:
irb->Base._ActualFormat = GL_RGB5;
irb->Base._BaseFormat = GL_RGBA;
irb->Base.RedBits = 5;
irb->Base.GreenBits = 6;
irb->Base.BlueBits = 5;
irb->Base.DataType = GL_UNSIGNED_BYTE;
break;
case GL_RGBA8:
irb->Base._ActualFormat = GL_RGBA8;
irb->Base._BaseFormat = GL_RGBA;
irb->Base.RedBits = 8;
irb->Base.GreenBits = 8;
irb->Base.BlueBits = 8;
irb->Base.AlphaBits = 8;
irb->Base.DataType = GL_UNSIGNED_BYTE;
break;
case GL_STENCIL_INDEX8_EXT:
irb->Base._ActualFormat = GL_STENCIL_INDEX8_EXT;
irb->Base._BaseFormat = GL_STENCIL_INDEX;
irb->Base.StencilBits = 8;
irb->Base.DataType = GL_UNSIGNED_BYTE;
break;
case GL_DEPTH_COMPONENT16:
irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
irb->Base.DepthBits = 16;
irb->Base.DataType = GL_UNSIGNED_SHORT;
break;
case GL_DEPTH_COMPONENT24:
irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
irb->Base.DepthBits = 24;
irb->Base.DataType = GL_UNSIGNED_INT;
break;
case GL_DEPTH24_STENCIL8_EXT:
irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
irb->Base.DepthBits = 24;
irb->Base.StencilBits = 8;
irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
break;
default:
_mesa_problem(NULL,
"Unexpected intFormat in intel_create_renderbuffer");
return NULL;
}
irb->Base.InternalFormat = intFormat;
/* intel-specific methods */
irb->Base.Delete = intel_delete_renderbuffer;
irb->Base.AllocStorage = intel_alloc_window_storage;
irb->Base.GetPointer = intel_get_pointer;
/* This sets the Get/PutRow/Value functions */
intel_set_span_functions(&irb->Base);
return irb;
}
/**
* Allocate a new driRenderbuffer object.
* Individual drivers are free to implement different versions of
* this function.
* \param format Either GL_RGBA, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24,
* GL_DEPTH_COMPONENT32, or GL_STENCIL_INDEX8_EXT (for now).
* \param cpp chars or bytes per pixel
* \param offset start of buffer with respect to framebuffer address
* \param pitch pixels per row
*/
driRenderbuffer *
driNewRenderbuffer(GLenum format, GLint cpp, GLint offset, GLint pitch)
{
driRenderbuffer *drb;
assert(format == GL_RGBA ||
format == GL_DEPTH_COMPONENT16 ||
format == GL_DEPTH_COMPONENT24 ||
format == GL_DEPTH_COMPONENT32 ||
format == GL_STENCIL_INDEX8_EXT);
assert(cpp > 0);
assert(pitch > 0);
drb = _mesa_calloc(sizeof(driRenderbuffer));
if (drb) {
const GLuint name = 0;
_mesa_init_renderbuffer(&drb->Base, name);
/* Make sure we're using a null-valued GetPointer routine */
assert(drb->Base.GetPointer(NULL, &drb->Base, 0, 0) == NULL);
drb->Base.InternalFormat = format;
if (format == GL_RGBA) {
/* Color */
drb->Base._BaseFormat = GL_RGBA;
drb->Base.DataType = GL_UNSIGNED_BYTE;
}
else if (format == GL_DEPTH_COMPONENT16) {
/* Depth */
drb->Base._BaseFormat = GL_DEPTH_COMPONENT;
/* we always Get/Put 32-bit Z values */
drb->Base.DataType = GL_UNSIGNED_INT;
}
else if (format == GL_DEPTH_COMPONENT24) {
/* Depth */
drb->Base._BaseFormat = GL_DEPTH_COMPONENT;
/* we always Get/Put 32-bit Z values */
drb->Base.DataType = GL_UNSIGNED_INT;
}
else {
/* Stencil */
ASSERT(format == GL_STENCIL_INDEX8);
drb->Base._BaseFormat = GL_STENCIL_INDEX;
drb->Base.DataType = GL_UNSIGNED_BYTE;
}
/* XXX if we were allocating a user-created renderbuffer, we'd have
* to fill in the ComponentSizes[] array too.
*/
drb->Base.AllocStorage = driRenderbufferStorage;
/* using default Delete function */
/* DRI renderbuffer-specific fields: */
drb->offset = offset;
drb->pitch = pitch;
drb->cpp = cpp;
}
return drb;
}
static struct GLFBDevRenderbufferRec *
new_glfbdev_renderbuffer(void *bufferStart, const GLFBDevVisualPtr visual)
{
struct GLFBDevRenderbufferRec *rb = CALLOC_STRUCT(GLFBDevRenderbufferRec);
if (rb) {
GLuint name = 0;
int pixelFormat = visual->pixelFormat;
_mesa_init_renderbuffer(&rb->Base, name);
rb->Base.Delete = delete_renderbuffer;
rb->Base.AllocStorage = renderbuffer_storage;
if (pixelFormat == PF_B8G8R8) {
rb->Base.GetRow = get_row_B8G8R8;
rb->Base.GetValues = get_values_B8G8R8;
rb->Base.PutRow = put_row_B8G8R8;
rb->Base.PutRowRGB = put_row_rgb_B8G8R8;
rb->Base.PutMonoRow = put_mono_row_B8G8R8;
rb->Base.PutValues = put_values_B8G8R8;
rb->Base.PutMonoValues = put_mono_values_B8G8R8;
}
else if (pixelFormat == PF_B8G8R8A8) {
rb->Base.GetRow = get_row_B8G8R8A8;
rb->Base.GetValues = get_values_B8G8R8A8;
rb->Base.PutRow = put_row_B8G8R8A8;
rb->Base.PutRowRGB = put_row_rgb_B8G8R8A8;
rb->Base.PutMonoRow = put_mono_row_B8G8R8A8;
rb->Base.PutValues = put_values_B8G8R8A8;
rb->Base.PutMonoValues = put_mono_values_B8G8R8A8;
}
else if (pixelFormat == PF_B5G6R5) {
rb->Base.GetRow = get_row_B5G6R5;
rb->Base.GetValues = get_values_B5G6R5;
rb->Base.PutRow = put_row_B5G6R5;
rb->Base.PutRowRGB = put_row_rgb_B5G6R5;
rb->Base.PutMonoRow = put_mono_row_B5G6R5;
rb->Base.PutValues = put_values_B5G6R5;
rb->Base.PutMonoValues = put_mono_values_B5G6R5;
}
else if (pixelFormat == PF_B5G5R5) {
rb->Base.GetRow = get_row_B5G5R5;
rb->Base.GetValues = get_values_B5G5R5;
rb->Base.PutRow = put_row_B5G5R5;
rb->Base.PutRowRGB = put_row_rgb_B5G5R5;
rb->Base.PutMonoRow = put_mono_row_B5G5R5;
rb->Base.PutValues = put_values_B5G5R5;
rb->Base.PutMonoValues = put_mono_values_B5G5R5;
}
rb->Base.InternalFormat = GL_RGBA;
rb->Base._BaseFormat = GL_RGBA;
rb->Base.DataType = GL_UNSIGNED_BYTE;
rb->Base.Data = bufferStart;
rb->rowStride = visual->var.xres_virtual * visual->var.bits_per_pixel / 8;
rb->bottom = (GLubyte *) bufferStart
+ (visual->var.yres - 1) * rb->rowStride;
rb->Base.Width = visual->var.xres;
rb->Base.Height = visual->var.yres;
/*
rb->Base.RedBits = visual->var.red.length;
rb->Base.GreenBits = visual->var.green.length;
rb->Base.BlueBits = visual->var.blue.length;
rb->Base.AlphaBits = visual->var.transp.length;
*/
rb->Base.InternalFormat = pixelFormat;
}
return rb;
}
MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
: BGLRenderer(view, options, dispatcher),
fBitmap(NULL),
fDirectModeEnabled(false),
fInfo(NULL),
fInfoLocker("info locker"),
fContext(NULL),
fVisual(NULL),
fFrameBuffer(NULL),
fFrontRenderBuffer(NULL),
fBackRenderBuffer(NULL),
fColorSpace(B_NO_COLOR_SPACE)
{
CALLED();
fClearColor[BE_RCOMP] = 0;
fClearColor[BE_GCOMP] = 0;
fClearColor[BE_BCOMP] = 0;
fClearColor[BE_ACOMP] = 0;
fClearIndex = 0;
fColorSpace = BScreen(GLView()->Window()).ColorSpace();
// We force single buffering for the time being
//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;
fOptions = options; // | BGL_INDIRECT;
struct dd_function_table functions;
fVisual = _mesa_create_visual(rgbFlag, dblFlag, stereoFlag, red, green,
blue, alpha, index, depth, stencil, accum, accum, accum,
alpha ? accum : 0, 1);
// Initialize device driver function table
_mesa_init_driver_functions(&functions);
functions.GetString = _GetString;
functions.UpdateState = _UpdateState;
functions.GetBufferSize = NULL;
functions.Error = _Error;
functions.Viewport = _Viewport;
functions.Flush = _Flush;
// create core context
fContext = _mesa_create_context(fVisual, NULL, &functions, this);
if (!fContext) {
_mesa_destroy_visual(fVisual);
return;
}
/* Initialize the software rasterizer and helper modules. */
_swrast_CreateContext(fContext);
_vbo_CreateContext(fContext);
_tnl_CreateContext(fContext);
_swsetup_CreateContext(fContext);
_swsetup_Wakeup(fContext);
// Use default TCL pipeline
TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline;
_mesa_enable_sw_extensions(fContext);
_mesa_enable_1_3_extensions(fContext);
_mesa_enable_1_4_extensions(fContext);
_mesa_enable_1_5_extensions(fContext);
_mesa_enable_2_0_extensions(fContext);
_mesa_enable_2_1_extensions(fContext);
// create core framebuffer
fFrameBuffer = (struct msr_framebuffer*)_mesa_calloc(
sizeof(*fFrameBuffer));
_mesa_initialize_framebuffer(&fFrameBuffer->Base, fVisual);
fFrontRenderBuffer = (struct msr_renderbuffer*)_mesa_calloc(
sizeof(*fFrontRenderBuffer));
_mesa_init_renderbuffer(&fFrontRenderBuffer->Base, 0);
fFrontRenderBuffer->Base.AllocStorage = _FrontRenderbufferStorage;
fFrontRenderBuffer->Base.Data = NULL;
fFrontRenderBuffer->Base.InternalFormat = GL_RGBA;
fFrontRenderBuffer->Base._BaseFormat = GL_RGBA;
fFrontRenderBuffer->Base.DataType = GL_UNSIGNED_BYTE;
fFrontRenderBuffer->Base.RedBits = 8 * sizeof(GLubyte);
fFrontRenderBuffer->Base.GreenBits = 8 * sizeof(GLubyte);
fFrontRenderBuffer->Base.BlueBits = 8 * sizeof(GLubyte);
fFrontRenderBuffer->Base.AlphaBits = 8 * sizeof(GLubyte);
_SetSpanFuncs(fFrontRenderBuffer, fColorSpace);
_mesa_add_renderbuffer(&fFrameBuffer->Base, BUFFER_FRONT_LEFT,
&fFrontRenderBuffer->Base);
if (dblFlag) {
fBackRenderBuffer = (struct msr_renderbuffer*)_mesa_calloc(
sizeof(*fBackRenderBuffer));
_mesa_init_renderbuffer(&fBackRenderBuffer->Base, 0);
fBackRenderBuffer->Base.AllocStorage = _BackRenderbufferStorage;
fBackRenderBuffer->Base.Data = NULL;
fBackRenderBuffer->Base.Delete = _DeleteBackBuffer;
fBackRenderBuffer->Base.InternalFormat = GL_RGBA;
fBackRenderBuffer->Base._BaseFormat = GL_RGBA;
fBackRenderBuffer->Base.DataType = GL_UNSIGNED_BYTE;
fBackRenderBuffer->Base.RedBits = 8 * sizeof(GLubyte);
fBackRenderBuffer->Base.GreenBits = 8 * sizeof(GLubyte);
fBackRenderBuffer->Base.BlueBits = 8 * sizeof(GLubyte);
fBackRenderBuffer->Base.AlphaBits = 8 * sizeof(GLubyte);
_SetSpanFuncs(fBackRenderBuffer, fColorSpace);
_mesa_add_renderbuffer(&fFrameBuffer->Base, BUFFER_BACK_LEFT,
&fBackRenderBuffer->Base);
}
_mesa_add_soft_renderbuffers(&fFrameBuffer->Base, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
BRect bounds = view->Bounds();
fWidth = fNewWidth = (GLint)bounds.Width();
fHeight = fNewHeight = (GLint)bounds.Height();
// some stupid applications (Quake2) don't even think about calling LockGL()
// before using glGetString and its glGet*() 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();
}
}
