219 lines
7.4 KiB
C
219 lines
7.4 KiB
C
#ifndef __glnamesint_h
|
|
#define __glnamesint_h
|
|
|
|
/*
|
|
** Copyright 1991, 1922, Silicon Graphics, Inc.
|
|
** All Rights Reserved.
|
|
**
|
|
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
|
|
** the contents of this file may not be disclosed to third parties, copied or
|
|
** duplicated in any form, in whole or in part, without the prior written
|
|
** permission of Silicon Graphics, Inc.
|
|
**
|
|
** RESTRICTED RIGHTS LEGEND:
|
|
** Use, duplication or disclosure by the Government is subject to restrictions
|
|
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
|
|
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
|
|
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
|
|
** rights reserved under the Copyright Laws of the United States.
|
|
**
|
|
** Display list internal structure description.
|
|
**
|
|
** $Revision: 1.2 $
|
|
** $Date: 1995/01/25 18:05:43 $
|
|
*/
|
|
|
|
|
|
/************************************************************************/
|
|
/*
|
|
** Names Manager Interface
|
|
**
|
|
** This file contains the Name Space Management types and structures.
|
|
**
|
|
** The Name Space Management code is used to store and retreive named
|
|
** data structures. The data being stored is referred to with void
|
|
** pointers to allow for the storage of any type of structure.
|
|
**
|
|
** The Name Space is implemented as a 2-3 tree. For a detailed
|
|
** description of its implementation, see lib/opengl/soft/so_names.c.
|
|
**
|
|
** __GLnamesArray is declared in types.h.
|
|
*/
|
|
/************************************************************************/
|
|
|
|
|
|
/*
|
|
** A tree can be used to hold different types of data,
|
|
** e.g. display lists or texture objects. This is the structure
|
|
** that contains information needed for each tree type. For
|
|
** example, this structure contains a pointer to a dummy empty
|
|
** structure and a callback for freeing memory associated with
|
|
** the structure.
|
|
*/
|
|
struct __GLnamesArrayTypeInfoRec {
|
|
void *empty; /* ptr to empty info structure */
|
|
GLuint dataSize; /* sizeof data structure in bytes */
|
|
void (WINAPIV *free)(__GLcontext *gc, void *memory);
|
|
/* callback for freeing data */
|
|
GLboolean (WINAPIV *alloc)(__GLcontext *gc, size_t size);
|
|
/* callback for allocating data */
|
|
};
|
|
typedef struct __GLnamesArrayTypeInfoRec __GLnamesArrayTypeInfo;
|
|
|
|
/*
|
|
** The number of spare branches and leaves that we keep about in case
|
|
** we run out of memory. At that point, we complete the current operation
|
|
** by using the extra leaves and branches, and we report an OUT_OF_MEMORY
|
|
** error when a new operation is requested (unless we can fill our extras
|
|
** again!)
|
|
**
|
|
** These constants were not chosen terribly carefully. As best as I can
|
|
** figure, we only need one spare branch per level in the tree (so 16
|
|
** supports a tree with 65536 leaves). And even then, the user would have
|
|
** to be extremely devious to actually force 16 new branches to appear in
|
|
** the tree at just the same moment that the system runs out of memory.
|
|
**
|
|
** The number of spare leaves required, I believe, is one. Three is chosen
|
|
** to allow for some slop.
|
|
*/
|
|
#define __GL_DL_EXTRA_BRANCHES 16
|
|
#define __GL_DL_EXTRA_LEAVES 3
|
|
|
|
/*
|
|
** This is the structure that contains information that is needed
|
|
** for each instance of a names tree. It needs to be public
|
|
** so the refcount can be managed.
|
|
*/
|
|
|
|
typedef struct __GLnamesArrayTypeInfoRec __GLnamesArrayTypeInfo;
|
|
typedef struct __GLnamesBranchRec __GLnamesBranch;
|
|
typedef struct __GLnamesLeafRec __GLnamesLeaf;
|
|
|
|
struct __GLnamesArrayRec {
|
|
__GLnamesBranch *tree; /* points to the top of the names tree */
|
|
GLuint depth; /* depth of tree */
|
|
GLint refcount; /*# ctxs using this array: create with 1, delete at 0*/
|
|
__GLnamesArrayTypeInfo *dataInfo; /* ptr to data type info */
|
|
GLuint nbranches, nleaves; /* should basically always be at max */
|
|
__GLnamesBranch *branches[__GL_DL_EXTRA_BRANCHES];
|
|
__GLnamesLeaf *leaves[__GL_DL_EXTRA_LEAVES];
|
|
#ifdef NT
|
|
CRITICAL_SECTION critsec;
|
|
#endif
|
|
};
|
|
|
|
#ifdef NT
|
|
// Locking macros to enable or disable locking
|
|
#define __GL_NAMES_LOCK(array) EnterCriticalSection(&(array)->critsec)
|
|
#define __GL_NAMES_UNLOCK(array) LeaveCriticalSection(&(array)->critsec)
|
|
|
|
#if DBG
|
|
typedef struct _RTL_CRITICAL_SECTION *LPCRITICAL_SECTION;
|
|
extern void APIENTRY CheckCritSectionIn(LPCRITICAL_SECTION pcs);
|
|
#define __GL_NAMES_ASSERT_LOCKED(array) CheckCritSectionIn(&(array)->critsec)
|
|
#else
|
|
#define __GL_NAMES_ASSERT_LOCKED(array)
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
** Clean up an item whose refcount has fallen to zero due to unlocking
|
|
*/
|
|
typedef void (FASTCALL *__GLnamesCleanupFunc)(__GLcontext *gc, void *data);
|
|
|
|
/*
|
|
** Allocate and initialize a new array structure.
|
|
*/
|
|
extern __GLnamesArray * FASTCALL __glNamesNewArray(__GLcontext *gc,
|
|
__GLnamesArrayTypeInfo *dataInfo);
|
|
|
|
/*
|
|
** Free the array structure.
|
|
*/
|
|
extern void FASTCALL __glNamesFreeArray(__GLcontext *gc, __GLnamesArray *array);
|
|
|
|
/*
|
|
** Save a new display list in the array. A return value of GL_FALSE
|
|
** indicates and OUT_OF_MEMORY error, indicating that the list was
|
|
** not stored.
|
|
*/
|
|
extern GLboolean FASTCALL __glNamesNewData(__GLcontext *gc, __GLnamesArray *array,
|
|
GLuint name, void *data);
|
|
|
|
/*
|
|
** Find and lock the list specified with "listnum". A return value of NULL
|
|
** indicates that there was no such list. __glNamesUnlockList() needs to
|
|
** be called to unlock the list otherwise.
|
|
*/
|
|
extern void * FASTCALL __glNamesLockData(__GLcontext *gc, __GLnamesArray *array,
|
|
GLuint name);
|
|
|
|
/*
|
|
** Unlock a list locked with __glNamesLockList(). If this is not called, then
|
|
** any memory associated with the list will never be freed when the list
|
|
** is deleted.
|
|
*/
|
|
extern void FASTCALL __glNamesUnlockData(__GLcontext *gc, void *data,
|
|
__GLnamesCleanupFunc cleanup);
|
|
|
|
/*
|
|
** Same as __glNamesLockList() except that a bunch of lists are locked and
|
|
** returned simultaneously. Any listbase previously specified is used as
|
|
** an offset to the entries in the array.
|
|
*/
|
|
extern void FASTCALL __glNamesLockDataList(__GLcontext *gc, __GLnamesArray *array,
|
|
GLsizei n, GLenum type, GLuint base,
|
|
const GLvoid *names, void *dataList[]);
|
|
|
|
/*
|
|
** Same as __glNamesUnlockList() except that the entire array of names
|
|
** is unlocked at once.
|
|
*/
|
|
extern void FASTCALL __glNamesUnlockDataList(__GLcontext *gc, GLsizei n,
|
|
void *dataList[],
|
|
__GLnamesCleanupFunc cleanup);
|
|
|
|
#ifdef NT
|
|
/*
|
|
** Locks entire array
|
|
*/
|
|
#define __glNamesLockArray(gc, array) __GL_NAMES_LOCK(array)
|
|
|
|
/*
|
|
** Unlocks array
|
|
*/
|
|
#define __glNamesUnlockArray(gc, array) __GL_NAMES_UNLOCK(array)
|
|
#endif
|
|
|
|
/*
|
|
** Generates a list of names.
|
|
*/
|
|
extern GLuint FASTCALL __glNamesGenRange(__GLcontext *gc, __GLnamesArray *array,
|
|
GLsizei range);
|
|
|
|
/*
|
|
** Returns GL_TRUE if name has been generated for this array.
|
|
*/
|
|
extern GLboolean FASTCALL __glNamesIsName(__GLcontext *gc, __GLnamesArray *array,
|
|
GLuint name);
|
|
|
|
/*
|
|
** Deletes a range of names.
|
|
*/
|
|
extern void FASTCALL __glNamesDeleteRange(__GLcontext *gc, __GLnamesArray *array,
|
|
GLuint name, GLsizei range);
|
|
|
|
/*
|
|
** Generates a list of (not necessarily contiguous) names.
|
|
*/
|
|
extern void FASTCALL __glNamesGenNames(__GLcontext *gc, __GLnamesArray *array,
|
|
GLsizei n, GLuint* names);
|
|
|
|
/*
|
|
** Deletes a list of (not necessarily contiguous) names.
|
|
*/
|
|
extern void FASTCALL __glNamesDeleteNames(__GLcontext *gc, __GLnamesArray *array,
|
|
GLsizei n, const GLuint* names);
|
|
|
|
#endif /* __glnamesint_h */
|