/** * 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(); } }