struct vg_context * vg_create_context(struct pipe_context *pipe,
const void *visual,
struct vg_context *share)
{
struct vg_context *ctx;
ctx = CALLOC_STRUCT(vg_context);
ctx->pipe = pipe;
if (!choose_depth_stencil_format(ctx)) {
FREE(ctx);
return NULL;
}
ctx->dispatch = api_create_dispatch();
vg_init_state(&ctx->state.vg);
ctx->state.dirty = ALL_DIRTY;
ctx->cso_context = cso_create_context(pipe);
ctx->default_paint = paint_create(ctx);
ctx->state.vg.stroke_paint = ctx->default_paint;
ctx->state.vg.fill_paint = ctx->default_paint;
ctx->mask.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->mask.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->mask.sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->mask.sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
ctx->mask.sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->mask.sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->mask.sampler.normalized_coords = 0;
ctx->blend_sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->blend_sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->blend_sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->blend_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
ctx->blend_sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->blend_sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->blend_sampler.normalized_coords = 0;
vg_set_error(ctx, VG_NO_ERROR);
ctx->owned_objects[VG_OBJECT_PAINT] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_IMAGE] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_MASK] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_FONT] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_PATH] = cso_hash_create();
ctx->renderer = renderer_create(ctx);
ctx->sc = shaders_cache_create(ctx);
ctx->shader = shader_create(ctx);
ctx->blit = util_create_blit(ctx->pipe, ctx->cso_context);
return ctx;
}
/*
* Create a new X/Mesa visual.
* Input: display - X11 display
* visinfo - an XVisualInfo pointer
* rgb_flag - GL_TRUE = RGB mode,
* GL_FALSE = color index mode
* alpha_flag - alpha buffer requested?
* db_flag - GL_TRUE = double-buffered,
* GL_FALSE = single buffered
* stereo_flag - stereo visual?
* ximage_flag - GL_TRUE = use an XImage for back buffer,
* GL_FALSE = use an off-screen pixmap for back buffer
* depth_size - requested bits/depth values, or zero
* stencil_size - requested bits/stencil values, or zero
* accum_red_size - requested bits/red accum values, or zero
* accum_green_size - requested bits/green accum values, or zero
* accum_blue_size - requested bits/blue accum values, or zero
* accum_alpha_size - requested bits/alpha accum values, or zero
* num_samples - number of samples/pixel if multisampling, or zero
* level - visual level, usually 0
* visualCaveat - ala the GLX extension, usually GLX_NONE
* Return; a new XMesaVisual or 0 if error.
*/
PUBLIC
XMesaVisual XMesaCreateVisual( Display *display,
XVisualInfo * visinfo,
GLboolean rgb_flag,
GLboolean alpha_flag,
GLboolean db_flag,
GLboolean stereo_flag,
GLboolean ximage_flag,
GLint depth_size,
GLint stencil_size,
GLint accum_red_size,
GLint accum_green_size,
GLint accum_blue_size,
GLint accum_alpha_size,
GLint num_samples,
GLint level,
GLint visualCaveat )
{
XMesaDisplay xmdpy = xmesa_init_display(display);
XMesaVisual v;
GLint red_bits, green_bits, blue_bits, alpha_bits;
if (!xmdpy)
return NULL;
/* For debugging only */
if (_mesa_getenv("MESA_XSYNC")) {
/* This makes debugging X easier.
* In your debugger, set a breakpoint on _XError to stop when an
* X protocol error is generated.
*/
XSynchronize( display, 1 );
}
v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
if (!v) {
return NULL;
}
v->display = display;
/* Save a copy of the XVisualInfo struct because the user may Xfree()
* the struct but we may need some of the information contained in it
* at a later time.
*/
v->visinfo = (XVisualInfo *) malloc(sizeof(*visinfo));
if (!v->visinfo) {
free(v);
return NULL;
}
memcpy(v->visinfo, visinfo, sizeof(*visinfo));
v->ximage_flag = ximage_flag;
v->mesa_visual.redMask = visinfo->red_mask;
v->mesa_visual.greenMask = visinfo->green_mask;
v->mesa_visual.blueMask = visinfo->blue_mask;
v->visualID = visinfo->visualid;
v->screen = visinfo->screen;
#if !(defined(__cplusplus) || defined(c_plusplus))
v->visualType = xmesa_convert_from_x_visual_type(visinfo->class);
#else
v->visualType = xmesa_convert_from_x_visual_type(visinfo->c_class);
#endif
v->mesa_visual.visualRating = visualCaveat;
if (alpha_flag)
v->mesa_visual.alphaBits = 8;
(void) initialize_visual_and_buffer( v, NULL, rgb_flag, 0, 0 );
{
const int xclass = v->visualType;
if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) {
red_bits = _mesa_bitcount(GET_REDMASK(v));
green_bits = _mesa_bitcount(GET_GREENMASK(v));
blue_bits = _mesa_bitcount(GET_BLUEMASK(v));
}
else {
/* this is an approximation */
int depth;
depth = v->visinfo->depth;
red_bits = depth / 3;
depth -= red_bits;
green_bits = depth / 2;
depth -= green_bits;
blue_bits = depth;
alpha_bits = 0;
assert( red_bits + green_bits + blue_bits == v->visinfo->depth );
}
alpha_bits = v->mesa_visual.alphaBits;
}
/* initialize visual */
{
struct gl_config *vis = &v->mesa_visual;
vis->rgbMode = GL_TRUE;
vis->doubleBufferMode = db_flag;
vis->stereoMode = stereo_flag;
vis->redBits = red_bits;
vis->greenBits = green_bits;
vis->blueBits = blue_bits;
vis->alphaBits = alpha_bits;
vis->rgbBits = red_bits + green_bits + blue_bits;
vis->indexBits = 0;
vis->depthBits = depth_size;
vis->stencilBits = stencil_size;
vis->accumRedBits = accum_red_size;
vis->accumGreenBits = accum_green_size;
vis->accumBlueBits = accum_blue_size;
vis->accumAlphaBits = accum_alpha_size;
vis->haveAccumBuffer = accum_red_size > 0;
vis->haveDepthBuffer = depth_size > 0;
vis->haveStencilBuffer = stencil_size > 0;
vis->numAuxBuffers = 0;
vis->level = 0;
vis->sampleBuffers = 0;
vis->samples = 0;
}
v->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
if (db_flag)
v->stvis.buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
if (stereo_flag) {
v->stvis.buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
if (db_flag)
v->stvis.buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
}
v->stvis.color_format = choose_pixel_format(v);
if (v->stvis.color_format == PIPE_FORMAT_NONE) {
free(v->visinfo);
free(v);
return NULL;
}
v->stvis.depth_stencil_format =
choose_depth_stencil_format(xmdpy, depth_size, stencil_size);
v->stvis.accum_format = (accum_red_size +
accum_green_size + accum_blue_size + accum_alpha_size) ?
PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
v->stvis.samples = num_samples;
v->stvis.render_buffer = ST_ATTACHMENT_INVALID;
/* XXX minor hack */
v->mesa_visual.level = level;
return v;
}
struct vg_context * vg_create_context(struct pipe_context *pipe,
const void *visual,
struct vg_context *share)
{
struct vg_context *ctx;
unsigned i;
ctx = CALLOC_STRUCT(vg_context);
ctx->pipe = pipe;
if (!choose_depth_stencil_format(ctx)) {
FREE(ctx);
return NULL;
}
ctx->dispatch = api_create_dispatch();
vg_init_state(&ctx->state.vg);
ctx->state.dirty = ALL_DIRTY;
ctx->cso_context = cso_create_context(pipe);
init_clear(ctx);
ctx->default_paint = paint_create(ctx);
ctx->state.vg.stroke_paint = ctx->default_paint;
ctx->state.vg.fill_paint = ctx->default_paint;
ctx->mask.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->mask.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->mask.sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
ctx->mask.sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->mask.sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->mask.sampler.normalized_coords = 0;
ctx->blend_sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->blend_sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->blend_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
ctx->blend_sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->blend_sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
ctx->blend_sampler.normalized_coords = 0;
for (i = 0; i < 2; i++) {
ctx->velems[i].src_offset = i * 4 * sizeof(float);
ctx->velems[i].instance_divisor = 0;
ctx->velems[i].vertex_buffer_index = 0;
ctx->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
}
vg_set_error(ctx, VG_NO_ERROR);
ctx->owned_objects[VG_OBJECT_PAINT] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_IMAGE] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_MASK] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_FONT] = cso_hash_create();
ctx->owned_objects[VG_OBJECT_PATH] = cso_hash_create();
ctx->renderer = renderer_create(ctx);
ctx->sc = shaders_cache_create(ctx);
ctx->shader = shader_create(ctx);
ctx->blit = util_create_blit(ctx->pipe, ctx->cso_context);
return ctx;
}
