removed unused R_Mesh_CacheArray stuff

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@6152 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/gl_backend.c b/gl_backend.c
index 11d3ac09fd03157a5ee6783eaa7a21969d1f4941..1e1ba225a9ea476092b401df8fdf712957568c7d 100644 (file)
--- a/gl_backend.c
+++ b/gl_backend.c
@@ -135,22 +135,12 @@ for (y = 0;y < rows - 1;y++)
 int polygonelements[(POLYGONELEMENTS_MAXPOINTS-2)*3];
 int quadelements[QUADELEMENTS_MAXQUADS*6];
 
-#if 0
-static void R_Mesh_CacheArray_Startup(void);
-static void R_Mesh_CacheArray_Shutdown(void);
-#endif
 void GL_Backend_AllocArrays(void)
 {
-#if 0
-       R_Mesh_CacheArray_Startup();
-#endif
 }
 
 void GL_Backend_FreeArrays(void)
 {
-#if 0
-       R_Mesh_CacheArray_Shutdown();
-#endif
 }
 
 static void gl_backend_start(void)
@@ -1654,10 +1644,6 @@ void R_Mesh_Draw_ShowTris(int firstvertex, int numvertices, int numtriangles, co
        CHECKGLERROR
 }
 
-//===========================================================================
-// dynamic vertex array buffer subsystem
-//===========================================================================
-
 // FIXME: someday this should be dynamically allocated and resized?
 float varray_vertex3f[65536*3];
 float varray_svector3f[65536*3];
@@ -1668,253 +1654,3 @@ float varray_texcoord2f[4][65536*2];
 float varray_texcoord3f[4][65536*3];
 int earray_element3i[65536];
 float varray_vertex3f2[65536*3];
-
-#if 0
-//===========================================================================
-// vertex array caching subsystem
-//===========================================================================
-
-typedef struct rcachearraylink_s
-{
-       struct rcachearraylink_s *next, *prev;
-       struct rcachearrayitem_s *data;
-}
-rcachearraylink_t;
-
-typedef struct rcachearrayitem_s
-{
-       // the original request structure
-       rcachearrayrequest_t request;
-       // active
-       int active;
-       // offset into r_mesh_rcachedata
-       int offset;
-       // for linking this into the sequential list
-       rcachearraylink_t sequentiallink;
-       // for linking this into the lookup list
-       rcachearraylink_t hashlink;
-}
-rcachearrayitem_t;
-
-#define RCACHEARRAY_HASHSIZE 65536
-#define RCACHEARRAY_ITEMS 4096
-#define RCACHEARRAY_DEFAULTSIZE (4 << 20)
-
-// all active items are linked into this chain in sorted order
-static rcachearraylink_t r_mesh_rcachesequentialchain;
-// all inactive items are linked into this chain in unknown order
-static rcachearraylink_t r_mesh_rcachefreechain;
-// all active items are also linked into these chains (using their hashlink)
-static rcachearraylink_t r_mesh_rcachechain[RCACHEARRAY_HASHSIZE];
-
-// all items are stored here, whether active or inactive
-static rcachearrayitem_t r_mesh_rcacheitems[RCACHEARRAY_ITEMS];
-
-// size of data buffer
-static int r_mesh_rcachedata_size = RCACHEARRAY_DEFAULTSIZE;
-// data buffer
-static unsigned char r_mesh_rcachedata[RCACHEARRAY_DEFAULTSIZE];
-
-// current state
-static int r_mesh_rcachedata_offset;
-static rcachearraylink_t *r_mesh_rcachesequentialchain_current;
-
-static void R_Mesh_CacheArray_Startup(void)
-{
-       int i;
-       rcachearraylink_t *l;
-       // prepare all the linked lists
-       l = &r_mesh_rcachesequentialchain;l->next = l->prev = l;l->data = NULL;
-       l = &r_mesh_rcachefreechain;l->next = l->prev = l;l->data = NULL;
-       memset(&r_mesh_rcachechain, 0, sizeof(r_mesh_rcachechain));
-       for (i = 0;i < RCACHEARRAY_HASHSIZE;i++)
-       {
-               l = &r_mesh_rcachechain[i];
-               l->next = l->prev = l;
-               l->data = NULL;
-       }
-       memset(&r_mesh_rcacheitems, 0, sizeof(r_mesh_rcacheitems));
-       for (i = 0;i < RCACHEARRAY_ITEMS;i++)
-       {
-               r_mesh_rcacheitems[i].hashlink.data = r_mesh_rcacheitems[i].sequentiallink.data = &r_mesh_rcacheitems[i];
-               l = &r_mesh_rcacheitems[i].sequentiallink;
-               l->next = &r_mesh_rcachefreechain;
-               l->prev = l->next->prev;
-               l->next->prev = l->prev->next = l;
-       }
-       // clear other state
-       r_mesh_rcachedata_offset = 0;
-       r_mesh_rcachesequentialchain_current = &r_mesh_rcachesequentialchain;
-}
-
-static void R_Mesh_CacheArray_Shutdown(void)
-{
-}
-
-/*
-static void R_Mesh_CacheArray_ValidateState(int num)
-{
-       rcachearraylink_t *l, *lhead;
-       lhead = &r_mesh_rcachesequentialchain;
-       if (r_mesh_rcachesequentialchain_current == lhead)
-               return;
-       for (l = lhead->next;l != lhead;l = l->next)
-               if (r_mesh_rcachesequentialchain_current == l)
-                       return;
-       Sys_Error("%i", num);
-}
-*/
-
-int R_Mesh_CacheArray(rcachearrayrequest_t *r)
-{
-       rcachearraylink_t *l, *lhead, *lnext;
-       rcachearrayitem_t *d;
-       int hashindex, offset, offsetend;
-
-       //R_Mesh_CacheArray_ValidateState(3);
-       // calculate a hashindex to choose a cache chain
-       r->data = NULL;
-       hashindex = CRC_Block((unsigned char *)r, sizeof(*r)) % RCACHEARRAY_HASHSIZE;
-
-       // is it already cached?
-       for (lhead = &r_mesh_rcachechain[hashindex], l = lhead->next;l != lhead;l = l->next)
-       {
-               if (!memcmp(&l->data->request, r, sizeof(l->data->request)))
-               {
-                       // we have it cached already
-                       r->data = r_mesh_rcachedata + l->data->offset;
-                       return false;
-               }
-       }
-
-       // we need to add a new cache item, this means finding a place for the new
-       // data and making sure we have a free item available, lots of work...
-
-       // check if buffer needs to wrap
-       if (r_mesh_rcachedata_offset + r->data_size > r_mesh_rcachedata_size)
-       {
-               /*
-               if (r->data_size * 10 > r_mesh_rcachedata_size)
-               {
-                       // realloc whole cache
-               }
-               */
-               // reset back to start
-               r_mesh_rcachedata_offset = 0;
-               r_mesh_rcachesequentialchain_current = &r_mesh_rcachesequentialchain;
-       }
-       offset = r_mesh_rcachedata_offset;
-       r_mesh_rcachedata_offset += r->data_size;
-       offsetend = r_mesh_rcachedata_offset;
-       //R_Mesh_CacheArray_ValidateState(4);
-
-       /*
-       {
-               int n;
-               for (lhead = &r_mesh_rcachesequentialchain, l = lhead->next, n = 0;l != lhead;l = l->next, n++);
-               Con_Printf("R_Mesh_CacheArray: new data range %i:%i, %i items are already linked\n", offset, offsetend, n);
-       }
-       */
-
-       // make room for the new data (remove old items)
-       lhead = &r_mesh_rcachesequentialchain;
-       l = r_mesh_rcachesequentialchain_current;
-       if (l == lhead)
-               l = l->next;
-       while (l != lhead && l->data->offset < offsetend && l->data->offset + l->data->request.data_size > offset)
-       {
-       //r_mesh_rcachesequentialchain_current = l;
-       //R_Mesh_CacheArray_ValidateState(8);
-               lnext = l->next;
-               // if at the end of the chain, wrap around
-               if (lnext == lhead)
-                       lnext = lnext->next;
-       //r_mesh_rcachesequentialchain_current = lnext;
-       //R_Mesh_CacheArray_ValidateState(10);
-
-               // unlink from sequential chain
-               l->next->prev = l->prev;
-               l->prev->next = l->next;
-       //R_Mesh_CacheArray_ValidateState(11);
-               // link into free chain
-               l->next = &r_mesh_rcachefreechain;
-               l->prev = l->next->prev;
-               l->next->prev = l->prev->next = l;
-       //R_Mesh_CacheArray_ValidateState(12);
-
-               l = &l->data->hashlink;
-               // unlink from hash chain
-               l->next->prev = l->prev;
-               l->prev->next = l->next;
-
-               l = lnext;
-       //r_mesh_rcachesequentialchain_current = l;
-       //R_Mesh_CacheArray_ValidateState(9);
-       }
-       //r_mesh_rcachesequentialchain_current = l;
-       //R_Mesh_CacheArray_ValidateState(5);
-       // gobble an extra item if we have no free items available
-       if (r_mesh_rcachefreechain.next == &r_mesh_rcachefreechain)
-       {
-               lnext = l->next;
-
-               // unlink from sequential chain
-               l->next->prev = l->prev;
-               l->prev->next = l->next;
-               // link into free chain
-               l->next = &r_mesh_rcachefreechain;
-               l->prev = l->next->prev;
-               l->next->prev = l->prev->next = l;
-
-               l = &l->data->hashlink;
-               // unlink from hash chain
-               l->next->prev = l->prev;
-               l->prev->next = l->next;
-
-               l = lnext;
-       }
-       r_mesh_rcachesequentialchain_current = l;
-       //R_Mesh_CacheArray_ValidateState(6);
-
-       // now take an item from the free chain
-       l = r_mesh_rcachefreechain.next;
-       // set it up
-       d = l->data;
-       d->request = *r;
-       d->offset = offset;
-       // unlink
-       l->next->prev = l->prev;
-       l->prev->next = l->next;
-       // relink to sequential
-       l->next = r_mesh_rcachesequentialchain_current->prev;
-       l->prev = l->next->prev;
-       while (l->next->data && l->data && l->next->data->offset <= d->offset)
-       {
-               //Con_Print(">\n");
-               l->next = l->next->next;
-               l->prev = l->prev->next;
-       }
-       while (l->prev->data && l->data && l->prev->data->offset >= d->offset)
-       {
-               //Con_Print("<\n");
-               l->prev = l->prev->prev;
-               l->next = l->next->prev;
-       }
-       l->next->prev = l->prev->next = l;
-       // also link into hash chain
-       l = &l->data->hashlink;
-       l->next = &r_mesh_rcachechain[hashindex];
-       l->prev = l->next->prev;
-       l->prev->next = l;
-       l->next->prev = l->prev->next = l;
-
-
-       //r_mesh_rcachesequentialchain_current = d->sequentiallink.next;
-
-       //R_Mesh_CacheArray_ValidateState(7);
-       // and finally set the data pointer
-       r->data = r_mesh_rcachedata + d->offset;
-       // and tell the caller to fill the array
-       return true;
-}
-#endif

diff --git a/gl_backend.h b/gl_backend.h
index 393d805a72433a0ce455a8cdaa97ff537d417a18..4adfec302e9b84ff392b1824d7a0bc93ce5945aa 100644 (file)
--- a/gl_backend.h
+++ b/gl_backend.h
@@ -108,29 +108,6 @@ void SCR_UpdateScreen(void);
 // invoke refresh of loading plaque (nothing else seen)
 void SCR_UpdateLoadingScreen(void);
 
-#if 0
-// public structure
-typedef struct rcachearrayrequest_s
-{
-       // for use by the code that is requesting the array, these are not
-       // directly used but merely compared to determine if cache items are
-       // identical
-       const void *id_pointer1;
-       const void *id_pointer2;
-       const void *id_pointer3;
-       int id_number1;
-       int id_number2;
-       int id_number3;
-       // size of array data
-       int data_size;
-       // array data pointer
-       void *data;
-}
-rcachearrayrequest_t;
-
-int R_Mesh_CacheArray(rcachearrayrequest_t *r);
-#endif
-
 extern float varray_vertex3f[65536*3];
 extern float varray_svector3f[65536*3];
 extern float varray_tvector3f[65536*3];