/**
* Create a new hash table.
*
* \return pointer to a new, empty hash table.
*/
struct _mesa_HashTable *
_mesa_NewHashTable(void)
{
struct _mesa_HashTable *table = CALLOC_STRUCT(_mesa_HashTable);
if (table) {
_glthread_INIT_MUTEX(table->Mutex);
_glthread_INIT_MUTEX(table->WalkMutex);
}
return table;
}
/**
* Initialize a new texture object to default values.
* \param obj the texture object
* \param name the texture name
* \param target the texture target
*/
void
_mesa_initialize_texture_object( struct gl_texture_object *obj,
GLuint name, GLenum target )
{
ASSERT(target == 0 ||
target == GL_TEXTURE_1D ||
target == GL_TEXTURE_2D ||
target == GL_TEXTURE_3D ||
target == GL_TEXTURE_CUBE_MAP_ARB ||
target == GL_TEXTURE_RECTANGLE_NV ||
target == GL_TEXTURE_1D_ARRAY_EXT ||
target == GL_TEXTURE_2D_ARRAY_EXT ||
target == GL_TEXTURE_EXTERNAL_OES ||
target == GL_TEXTURE_BUFFER);
memset(obj, 0, sizeof(*obj));
/* init the non-zero fields */
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
obj->Name = name;
obj->Target = target;
obj->Priority = 1.0F;
obj->BaseLevel = 0;
obj->MaxLevel = 1000;
/* must be one; no support for (YUV) planes in separate buffers */
obj->RequiredTextureImageUnits = 1;
/* sampler state */
if (target == GL_TEXTURE_RECTANGLE_NV ||
target == GL_TEXTURE_EXTERNAL_OES) {
obj->Sampler.WrapS = GL_CLAMP_TO_EDGE;
obj->Sampler.WrapT = GL_CLAMP_TO_EDGE;
obj->Sampler.WrapR = GL_CLAMP_TO_EDGE;
obj->Sampler.MinFilter = GL_LINEAR;
}
else {
obj->Sampler.WrapS = GL_REPEAT;
obj->Sampler.WrapT = GL_REPEAT;
obj->Sampler.WrapR = GL_REPEAT;
obj->Sampler.MinFilter = GL_NEAREST_MIPMAP_LINEAR;
}
obj->Sampler.MagFilter = GL_LINEAR;
obj->Sampler.MinLod = -1000.0;
obj->Sampler.MaxLod = 1000.0;
obj->Sampler.LodBias = 0.0;
obj->Sampler.MaxAnisotropy = 1.0;
obj->Sampler.CompareMode = GL_NONE; /* ARB_shadow */
obj->Sampler.CompareFunc = GL_LEQUAL; /* ARB_shadow */
obj->DepthMode = GL_LUMINANCE;
obj->Sampler.CubeMapSeamless = GL_FALSE;
obj->Swizzle[0] = GL_RED;
obj->Swizzle[1] = GL_GREEN;
obj->Swizzle[2] = GL_BLUE;
obj->Swizzle[3] = GL_ALPHA;
obj->_Swizzle = SWIZZLE_NOOP;
obj->Sampler.sRGBDecode = GL_DECODE_EXT;
obj->BufferObjectFormat = GL_LUMINANCE8;
obj->_BufferObjectFormat = MESA_FORMAT_L8;
}
/**
* Initialize a new texture object to default values.
* \param obj the texture object
* \param name the texture name
* \param target the texture target
*/
void
_mesa_initialize_texture_object( struct gl_texture_object *obj,
GLuint name, GLenum target )
{
ASSERT(target == 0 ||
target == GL_TEXTURE_1D ||
target == GL_TEXTURE_2D ||
target == GL_TEXTURE_3D ||
target == GL_TEXTURE_CUBE_MAP_ARB);
memset(obj, 0, sizeof(*obj));
/* init the non-zero fields */
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
obj->Name = name;
obj->Target = target;
obj->Priority = 1.0F;
obj->BaseLevel = 0;
obj->MaxLevel = 1000;
/* sampler state */
obj->Sampler.WrapS = GL_REPEAT;
obj->Sampler.WrapT = GL_REPEAT;
obj->Sampler.WrapR = GL_REPEAT;
obj->Sampler.MinFilter = GL_NEAREST_MIPMAP_LINEAR;
obj->Sampler.MagFilter = GL_LINEAR;
obj->Sampler.MaxAnisotropy = 1.0;
}
/**
* Initialize the state associated with buffer objects
*/
void
_mesa_init_buffer_objects( struct gl_context *ctx )
{
memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));
_glthread_INIT_MUTEX(DummyBufferObject.Mutex);
DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */
}
/**
* Initialize a gl_array_object's arrays.
*/
void
_mesa_initialize_array_object( struct gl_context *ctx,
struct gl_array_object *obj,
GLuint name )
{
GLuint i;
obj->Name = name;
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
/* Init the individual arrays */
init_array(ctx, &obj->Vertex, 4, GL_FLOAT);
init_array(ctx, &obj->Weight, 1, GL_FLOAT);
init_array(ctx, &obj->Normal, 3, GL_FLOAT);
init_array(ctx, &obj->Color, 4, GL_FLOAT);
init_array(ctx, &obj->SecondaryColor, 3, GL_FLOAT);
init_array(ctx, &obj->FogCoord, 1, GL_FLOAT);
init_array(ctx, &obj->Index, 1, GL_FLOAT);
for (i = 0; i < Elements(obj->TexCoord); i++) {
init_array(ctx, &obj->TexCoord[i], 4, GL_FLOAT);
}
init_array(ctx, &obj->EdgeFlag, 1, GL_BOOL);
for (i = 0; i < Elements(obj->VertexAttrib); i++) {
init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT);
}
#if FEATURE_point_size_array
init_array(ctx, &obj->PointSize, 1, GL_FLOAT);
#endif
}
/**
* Initialize a gl_framebuffer object. Typically used to initialize
* window system-created framebuffers, not user-created framebuffers.
* \sa _mesa_create_framebuffer
*/
void
_mesa_initialize_framebuffer(struct gl_framebuffer *fb, const GLvisual *visual)
{
assert(fb);
assert(visual);
_mesa_bzero(fb, sizeof(struct gl_framebuffer));
_glthread_INIT_MUTEX(fb->Mutex);
fb->RefCount = 1;
/* save the visual */
fb->Visual = *visual;
/* Init glRead/DrawBuffer state */
if (visual->doubleBufferMode) {
fb->ColorDrawBuffer[0] = GL_BACK;
fb->_ColorDrawBufferMask[0] = BUFFER_BIT_BACK_LEFT;
fb->ColorReadBuffer = GL_BACK;
fb->_ColorReadBufferIndex = BUFFER_BACK_LEFT;
}
else {
fb->ColorDrawBuffer[0] = GL_FRONT;
fb->_ColorDrawBufferMask[0] = BUFFER_BIT_FRONT_LEFT;
fb->ColorReadBuffer = GL_FRONT;
fb->_ColorReadBufferIndex = BUFFER_FRONT_LEFT;
}
fb->Delete = _mesa_destroy_framebuffer;
fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;
compute_depth_max(fb);
}
boolean
stw_init(const struct stw_winsys *stw_winsys)
{
static struct stw_device stw_dev_storage;
struct pipe_screen *screen;
debug_printf("%s\n", __FUNCTION__);
assert(!stw_dev);
stw_tls_init();
stw_dev = &stw_dev_storage;
memset(stw_dev, 0, sizeof(*stw_dev));
#ifdef DEBUG
stw_dev->memdbg_no = debug_memory_begin();
#endif
stw_dev->stw_winsys = stw_winsys;
#ifdef WIN32_THREADS
_glthread_INIT_MUTEX(OneTimeLock);
#endif
screen = stw_winsys->create_screen();
if(!screen)
goto error1;
#ifdef DEBUG
stw_dev->screen = trace_screen_create(screen);
stw_dev->trace_running = stw_dev->screen != screen ? TRUE : FALSE;
#else
stw_dev->screen = screen;
#endif
stw_dev->screen->flush_frontbuffer = &stw_flush_frontbuffer;
pipe_mutex_init( stw_dev->ctx_mutex );
pipe_mutex_init( stw_dev->fb_mutex );
stw_dev->ctx_table = handle_table_create();
if (!stw_dev->ctx_table) {
goto error1;
}
stw_pixelformat_init();
return TRUE;
error1:
stw_dev = NULL;
return FALSE;
}
/**
* Initialize a buffer object to default values.
*/
void
_mesa_initialize_buffer_object( struct gl_context *ctx,
struct gl_buffer_object *obj,
GLuint name, GLenum target )
{
(void) target;
memset(obj, 0, sizeof(struct gl_buffer_object));
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
obj->Name = name;
obj->Usage = GL_STATIC_DRAW_ARB;
obj->AccessFlags = default_access_mode(ctx);
}
/**
* Initialize a gl_array_object's arrays.
*/
void
_mesa_initialize_array_object( struct gl_context *ctx,
struct gl_array_object *obj,
GLuint name )
{
GLuint i;
obj->Name = name;
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
/* Init the individual arrays */
for (i = 0; i < Elements(obj->VertexAttrib); i++) {
switch (i) {
case VERT_ATTRIB_WEIGHT:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_WEIGHT], 1, GL_FLOAT);
break;
case VERT_ATTRIB_NORMAL:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_NORMAL], 3, GL_FLOAT);
break;
case VERT_ATTRIB_COLOR1:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_COLOR1], 3, GL_FLOAT);
break;
case VERT_ATTRIB_FOG:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_FOG], 1, GL_FLOAT);
break;
case VERT_ATTRIB_COLOR_INDEX:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX], 1, GL_FLOAT);
break;
case VERT_ATTRIB_EDGEFLAG:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_EDGEFLAG], 1, GL_BOOL);
break;
#if FEATURE_point_size_array
case VERT_ATTRIB_POINT_SIZE:
init_array(ctx, &obj->VertexAttrib[VERT_ATTRIB_POINT_SIZE], 1, GL_FLOAT);
break;
#endif
default:
init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT);
break;
}
}
_mesa_reference_buffer_object(ctx, &obj->ElementArrayBufferObj,
ctx->Shared->NullBufferObj);
}
/**
* Initialize a new texture object to default values.
* \param obj the texture object
* \param name the texture name
* \param target the texture target
*/
void
_mesa_initialize_texture_object( struct gl_texture_object *obj,
GLuint name, GLenum target )
{
ASSERT(target == 0 ||
target == GL_TEXTURE_1D ||
target == GL_TEXTURE_2D ||
target == GL_TEXTURE_3D ||
target == GL_TEXTURE_CUBE_MAP_ARB ||
target == GL_TEXTURE_RECTANGLE_NV);
_mesa_bzero(obj, sizeof(*obj));
/* init the non-zero fields */
_glthread_INIT_MUTEX(obj->Mutex);
obj->RefCount = 1;
obj->Name = name;
obj->Target = target;
obj->Priority = 1.0F;
if (target == GL_TEXTURE_RECTANGLE_NV) {
obj->WrapS = GL_CLAMP_TO_EDGE;
obj->WrapT = GL_CLAMP_TO_EDGE;
obj->WrapR = GL_CLAMP_TO_EDGE;
obj->MinFilter = GL_LINEAR;
}
else {
obj->WrapS = GL_REPEAT;
obj->WrapT = GL_REPEAT;
obj->WrapR = GL_REPEAT;
obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
}
obj->MagFilter = GL_LINEAR;
obj->MinLod = -1000.0;
obj->MaxLod = 1000.0;
obj->LodBias = 0.0;
obj->BaseLevel = 0;
obj->MaxLevel = 1000;
obj->MaxAnisotropy = 1.0;
obj->CompareFlag = GL_FALSE; /* SGIX_shadow */
obj->CompareOperator = GL_TEXTURE_LEQUAL_R_SGIX; /* SGIX_shadow */
obj->CompareMode = GL_NONE; /* ARB_shadow */
obj->CompareFunc = GL_LEQUAL; /* ARB_shadow */
obj->DepthMode = GL_LUMINANCE; /* ARB_depth_texture */
obj->ShadowAmbient = 0.0F; /* ARB/SGIX_shadow_ambient */
_mesa_init_colortable(&obj->Palette);
}
/**
* Initialize a user-created gl_framebuffer object.
* \sa _mesa_initialize_window_framebuffer
*/
void
_mesa_initialize_user_framebuffer(struct gl_framebuffer *fb, GLuint name)
{
assert(fb);
assert(name);
memset(fb, 0, sizeof(struct gl_framebuffer));
fb->Name = name;
fb->RefCount = 1;
fb->_NumColorDrawBuffers = 1;
fb->ColorDrawBuffer[0] = GL_COLOR_ATTACHMENT0_EXT;
fb->_ColorDrawBufferIndexes[0] = BUFFER_COLOR0;
fb->ColorReadBuffer = GL_COLOR_ATTACHMENT0_EXT;
fb->_ColorReadBufferIndex = BUFFER_COLOR0;
fb->Delete = _mesa_destroy_framebuffer;
_glthread_INIT_MUTEX(fb->Mutex);
}
/**
* Initialize the fields of a gl_renderbuffer to default values.
*/
void
_mesa_init_renderbuffer(struct gl_renderbuffer *rb, GLuint name)
{
_glthread_INIT_MUTEX(rb->Mutex);
rb->ClassID = 0;
rb->Name = name;
rb->RefCount = 0;
rb->Delete = _mesa_delete_renderbuffer;
/* The rest of these should be set later by the caller of this function or
* the AllocStorage method:
*/
rb->AllocStorage = NULL;
rb->Width = 0;
rb->Height = 0;
rb->InternalFormat = GL_RGBA;
rb->Format = MESA_FORMAT_NONE;
}
/**
* Initialize a gl_framebuffer object. Typically used to initialize
* window system-created framebuffers, not user-created framebuffers.
* \sa _mesa_initialize_user_framebuffer
*/
void
_mesa_initialize_window_framebuffer(struct gl_framebuffer *fb,
const struct gl_config *visual)
{
assert(fb);
assert(visual);
memset(fb, 0, sizeof(struct gl_framebuffer));
_glthread_INIT_MUTEX(fb->Mutex);
fb->RefCount = 1;
/* save the visual */
fb->Visual = *visual;
/* Init read/draw renderbuffer state */
if (visual->doubleBufferMode) {
fb->_NumColorDrawBuffers = 1;
fb->ColorDrawBuffer[0] = GL_BACK;
fb->_ColorDrawBufferIndexes[0] = BUFFER_BACK_LEFT;
fb->ColorReadBuffer = GL_BACK;
fb->_ColorReadBufferIndex = BUFFER_BACK_LEFT;
}
else {
fb->_NumColorDrawBuffers = 1;
fb->ColorDrawBuffer[0] = GL_FRONT;
fb->_ColorDrawBufferIndexes[0] = BUFFER_FRONT_LEFT;
fb->ColorReadBuffer = GL_FRONT;
fb->_ColorReadBufferIndex = BUFFER_FRONT_LEFT;
}
fb->Delete = _mesa_destroy_framebuffer;
fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;
compute_depth_max(fb);
}
struct bufmgr *
bm_intel_Attach(struct intel_context *intel)
{
GLuint i;
for (i = 0; i < nr_bms; i++)
if (bufmgr_pool[i].driFd == intel->driFd) {
bufmgr_pool[i].refcount++;
_mesa_printf("retrieive old bufmgr for fd %d\n",
bufmgr_pool[i].driFd);
return &bufmgr_pool[i];
}
if (nr_bms < BM_MAX) {
struct bufmgr *bm = &bufmgr_pool[nr_bms++];
_mesa_printf("create new bufmgr for fd %d\n", intel->driFd);
bm->driFd = intel->driFd;
bm->hash = _mesa_NewHashTable();
bm->refcount = 1;
_glthread_INIT_MUTEX(bm->mutex);
drmGetLock(bm->driFd, intel->hHWContext, 0);
BM_CKFATAL(drmMMAllocBufferPool(bm->driFd, mmPoolRing, 0,
DRM_MM_TT | DRM_MM_NO_EVICT |
DRM_MM_READ | DRM_MM_EXE |
BM_BATCHBUFFER, 1024 * 1024, 4096,
&bm->batchPool));
drmUnlock(bm->driFd, intel->hHWContext);
return bm;
}
_mesa_printf("failed to create new bufmgr for fd %d\n", intel->driFd);
return NULL;
}
/**
* Allocate and initialize a shared context state structure.
* Initializes the display list, texture objects and vertex programs hash
* tables, allocates the texture objects. If it runs out of memory, frees
* everything already allocated before returning NULL.
*
* \return pointer to a gl_shared_state structure on success, or NULL on
* failure.
*/
struct gl_shared_state *
_mesa_alloc_shared_state(GLcontext *ctx)
{
struct gl_shared_state *shared;
GLuint i;
shared = CALLOC_STRUCT(gl_shared_state);
if (!shared)
return NULL;
_glthread_INIT_MUTEX(shared->Mutex);
shared->DisplayList = _mesa_NewHashTable();
shared->TexObjects = _mesa_NewHashTable();
shared->Programs = _mesa_NewHashTable();
#if FEATURE_ARB_vertex_program
shared->DefaultVertexProgram = (struct gl_vertex_program *)
ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
#endif
#if FEATURE_ARB_fragment_program
shared->DefaultFragmentProgram = (struct gl_fragment_program *)
ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
#endif
#if FEATURE_ATI_fragment_shader
shared->ATIShaders = _mesa_NewHashTable();
shared->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
#endif
#if FEATURE_ARB_shader_objects
shared->ShaderObjects = _mesa_NewHashTable();
#endif
#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
shared->BufferObjects = _mesa_NewHashTable();
#endif
shared->ArrayObjects = _mesa_NewHashTable();
/* Create default texture objects */
for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
/* NOTE: the order of these enums matches the TEXTURE_x_INDEX values */
static const GLenum targets[NUM_TEXTURE_TARGETS] = {
GL_TEXTURE_2D_ARRAY_EXT,
GL_TEXTURE_1D_ARRAY_EXT,
GL_TEXTURE_CUBE_MAP,
GL_TEXTURE_3D,
GL_TEXTURE_RECTANGLE_NV,
GL_TEXTURE_2D,
GL_TEXTURE_1D
};
shared->DefaultTex[i] = ctx->Driver.NewTextureObject(ctx, 0, targets[i]);
}
/* sanity check */
assert(shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount == 1);
/* Mutex and timestamp for texobj state validation */
_glthread_INIT_MUTEX(shared->TexMutex);
shared->TextureStateStamp = 0;
#if FEATURE_EXT_framebuffer_object
shared->FrameBuffers = _mesa_NewHashTable();
shared->RenderBuffers = _mesa_NewHashTable();
#endif
return shared;
}
/**
* Create a new XMesaContext.
* \param v the XMesaVisual
* \param share_list another XMesaContext with which to share display
* lists or NULL if no sharing is wanted.
* \return an XMesaContext or NULL if error.
*/
PUBLIC
XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
{
static GLboolean firstTime = GL_TRUE;
XMesaContext c;
struct gl_context *mesaCtx;
struct dd_function_table functions;
TNLcontext *tnl;
if (firstTime) {
_glthread_INIT_MUTEX(_xmesa_lock);
firstTime = GL_FALSE;
}
/* Note: the XMesaContext contains a Mesa struct gl_context struct (inheritance) */
c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
if (!c)
return NULL;
mesaCtx = &(c->mesa);
/* initialize with default driver functions, then plug in XMesa funcs */
_mesa_init_driver_functions(&functions);
xmesa_init_driver_functions(v, &functions);
if (!_mesa_initialize_context(mesaCtx, API_OPENGL_COMPAT, &v->mesa_visual,
share_list ? &(share_list->mesa) : (struct gl_context *) NULL,
&functions)) {
free(c);
return NULL;
}
/* Enable this to exercise fixed function -> shader translation
* with software rendering.
*/
if (0) {
mesaCtx->VertexProgram._MaintainTnlProgram = GL_TRUE;
mesaCtx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
}
_mesa_enable_sw_extensions(mesaCtx);
_mesa_enable_1_3_extensions(mesaCtx);
_mesa_enable_1_4_extensions(mesaCtx);
_mesa_enable_1_5_extensions(mesaCtx);
_mesa_enable_2_0_extensions(mesaCtx);
_mesa_enable_2_1_extensions(mesaCtx);
if (mesaCtx->Mesa_DXTn) {
mesaCtx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
mesaCtx->Extensions.ANGLE_texture_compression_dxt = GL_TRUE;
}
mesaCtx->Extensions.TDFX_texture_compression_FXT1 = GL_TRUE;
#if ENABLE_EXT_timer_query
mesaCtx->Extensions.EXT_timer_query = GL_TRUE;
#endif
/* finish up xmesa context initializations */
c->swapbytes = CHECK_BYTE_ORDER(v) ? GL_FALSE : GL_TRUE;
c->xm_visual = v;
c->xm_buffer = NULL; /* set later by XMesaMakeCurrent */
c->display = v->display;
c->pixelformat = v->dithered_pf; /* Dithering is enabled by default */
/* Initialize the software rasterizer and helper modules.
*/
if (!_swrast_CreateContext( mesaCtx ) ||
!_vbo_CreateContext( mesaCtx ) ||
!_tnl_CreateContext( mesaCtx ) ||
!_swsetup_CreateContext( mesaCtx )) {
_mesa_free_context_data(&c->mesa);
free(c);
return NULL;
}
/* tnl setup */
tnl = TNL_CONTEXT(mesaCtx);
tnl->Driver.RunPipeline = _tnl_run_pipeline;
/* swrast setup */
xmesa_register_swrast_functions( mesaCtx );
_swsetup_Wakeup(mesaCtx);
_mesa_meta_init(mesaCtx);
_mesa_compute_version(mesaCtx);
/* Exec table initialization requires the version to be computed */
_mesa_initialize_dispatch_tables(mesaCtx);
_mesa_initialize_vbo_vtxfmt(mesaCtx);
return c;
}
