WebSVN – eduke32 – Diff – /polymer/eduke32/build/src/engine.c



        { lastageclock = totalclock; agecache(); }

#ifdef USE_OPENGL
    omdtims = mdtims; mdtims = getticks();

 
 
    for (int i = 0; i < Numsprites; i++)
        if ((mdpause && spriteext[i].mdanimtims) || (spriteext[i].flags & SPREXT_NOMDANIM))
            spriteext[i].mdanimtims += mdtims - omdtims;
 
#endif

    beforedrawrooms = 1;
    numframes++;
}

// setrollangle
//
#ifdef USE_OPENGL
void setrollangle(int32_t rolla)
{
    gtang = (float)rolla * (PI * (1.f/1024.f));
}
#endif


//

    UNREFERENCED_PARAMETER(pal);
    UNREFERENCED_PARAMETER(how);
#else
    if (getrendermode() >= REND_POLYMOST)
    {
 
 
        const int32_t firstpal = (pal < 0) ? 0 : pal;
        const int32_t numpals = (pal < 0) ? MAXPALOOKUPS : 1;

        for (int hp = 0; hp <= 4; hp+=4)
        {
            if (how & pow2long[hp])
                for (int np = firstpal; np < firstpal+numpals; np++)
                    gltexinvalidate(tilenume, np, hp);
        }

#ifdef POLYMER
        if (getrendermode() == REND_POLYMER)

{
#ifdef USE_OPENGL
    if (getrendermode() < REND_POLYMOST) return;

    bglViewport(0,0,xres,yres);

    bglMatrixMode(GL_PROJECTION);
    bglLoadIdentity();
    bglOrtho(0,xres,yres,0,-1,1);

    if (getrendermode() == REND_POLYMER)
    {
        bglMatrixMode(GL_MODELVIEW);
        bglLoadIdentity();
    }

    gloy1 = -1;

    bglDisable(GL_DEPTH_TEST);
    bglDisable(GL_TEXTURE_2D);

    t->items=(hashitem_t **)Xcalloc(1, t->size * sizeof(hashitem_t));
}

void hash_free(hashtable_t *t)
{
 
 
 
 
    if (t->items == NULL)
        return;
 

    int remaining = t->size - 1;

    do
    {
        hashitem_t *cur = t->items[remaining];

        int num = 0;

        while (cur)
        {
            hashitem_t * const tmp = cur;
            cur = cur->next;
 

            if (tmp->string)
            {
                Bfree(tmp->string);
                tmp->string = NULL;
            }
            Bfree(tmp);
            num++;
        }
    } while (--remaining >= 0);

 
    Bfree(t->items);
    t->items = 0;
}

// djb3 algorithm

    return h;
}

void hash_add(hashtable_t *t, const char *s, intptr_t key, int32_t replace)
{
 
 
 
    if (EDUKE32_PREDICT_FALSE(t->items == NULL))
    {
        initprintf("hash_add(): table not initialized!\n");
        return;
    }

    uint32_t code = hash_getcode(s) % t->size;
    hashitem_t *cur = t->items[code];

    if (!cur)
    {
        cur = (hashitem_t *)Xcalloc(1,sizeof(hashitem_t));
        cur->string = Xstrdup(s);

        cur->next = NULL;
        t->items[code] = cur;
        return;
    }

    hashitem_t *prev = NULL;

    do
    {
        if (Bstrcmp(s,cur->string) == 0)
        {
            if (replace) cur->key = key;

}

// delete at most once
void hash_delete(hashtable_t *t, const char *s)
{
 
 
 
    if (t->items == NULL)
    {
        initprintf("hash_delete(): table not initialized!\n");
        return;
    }

    uint32_t code = hash_getcode(s) % t->size;
    hashitem_t *cur = t->items[code];

    if (!cur)
        return;

    hashitem_t *prev = NULL;

    do
    {
        if (Bstrcmp(s, cur->string) == 0)
        {
            Bfree(cur->string);

            else
                prev->next = cur->next;

            Bfree(cur);

            break;
        }
        prev = cur;
    }
    while ((cur = cur->next));
}

intptr_t hash_find(const hashtable_t *t, const char *s)
{
 
 
    if (t->items == NULL)
    {
        initprintf("hash_find(): table not initialized!\n");
        return -1;
    }

    hashitem_t *cur = t->items[hash_getcode(s) % t->size];

    if (!cur)
        return -1;

    do
        if (Bstrcmp(s, cur->string) == 0)
            return cur->key;
    while ((cur = cur->next));

    return -1;
}

intptr_t hash_findcase(const hashtable_t *t, const char *s)
{
 

    if (t->items == NULL)
    {
        initprintf("hash_findcase(): table not initialized!\n");
        return -1;
    }

    hashitem_t *cur = t->items[hash_getcode(s) % t->size];

    if (!cur)
        return -1;

    do
        if (Bstrcasecmp(s, cur->string) == 0)
            return cur->key;
    while ((cur = cur->next));

Rev 5056	Rev 5071
Line 11833...	Line 11833...
11833	{ lastageclock = totalclock; agecache(); }	11833	{ lastageclock = totalclock; agecache(); }
11834		11834
11835	#ifdef USE_OPENGL	11835	#ifdef USE_OPENGL
11836	omdtims = mdtims; mdtims = getticks();	11836	omdtims = mdtims; mdtims = getticks();
11837		11837
11838	{	-
11839	int32_t i;	-
11840	for (i=0; i<MAXSPRITES; i++)	11838	for (int i = 0; i < Numsprites; i++)
11841	if ((mdpause&&spriteext[i].mdanimtims)\|\|(spriteext[i].flags & SPREXT_NOMDANIM))	11839	if ((mdpause && spriteext[i].mdanimtims) \|\| (spriteext[i].flags & SPREXT_NOMDANIM))
11842	spriteext[i].mdanimtims+=mdtims-omdtims;	11840	spriteext[i].mdanimtims += mdtims - omdtims;
11843	}	-
11844	#endif	11841	#endif
11845		11842
11846	beforedrawrooms = 1;	11843	beforedrawrooms = 1;
11847	numframes++;	11844	numframes++;
11848	}	11845	}
Line 17986...	Line 17983...
17986	// setrollangle	17983	// setrollangle
17987	//	17984	//
17988	#ifdef USE_OPENGL	17985	#ifdef USE_OPENGL
17989	void setrollangle(int32_t rolla)	17986	void setrollangle(int32_t rolla)
17990	{	17987	{
17991	gtang = (float)rolla * PI * (1.f/1024.f);	17988	gtang = (float)rolla * (PI * (1.f/1024.f));
17992	}	17989	}
17993	#endif	17990	#endif
17994		17991
17995		17992
17996	//	17993	//
Line 18014...	Line 18011...
18014	UNREFERENCED_PARAMETER(pal);	18011	UNREFERENCED_PARAMETER(pal);
18015	UNREFERENCED_PARAMETER(how);	18012	UNREFERENCED_PARAMETER(how);
18016	#else	18013	#else
18017	if (getrendermode() >= REND_POLYMOST)	18014	if (getrendermode() >= REND_POLYMOST)
18018	{	18015	{
18019	int32_t hp, np;	-
18020		-
18021	const int32_t firstpal = (pal < 0) ? 0 : pal;	18016	const int32_t firstpal = (pal < 0) ? 0 : pal;
18022	const int32_t numpals = (pal < 0) ? MAXPALOOKUPS : 1;	18017	const int32_t numpals = (pal < 0) ? MAXPALOOKUPS : 1;
18023		18018
18024	for (hp = 0; hp <= 4; hp+=4)	18019	for (int hp = 0; hp <= 4; hp+=4)
18025	{	18020	{
18026	if (how & pow2long[hp])	18021	if (how & pow2long[hp])
18027	for (np = firstpal; np < firstpal+numpals; np++)	18022	for (int np = firstpal; np < firstpal+numpals; np++)
18028	gltexinvalidate(tilenume, np, hp);	18023	gltexinvalidate(tilenume, np, hp);
18029	}	18024	}
18030		18025
18031	#ifdef POLYMER	18026	#ifdef POLYMER
18032	if (getrendermode() == REND_POLYMER)	18027	if (getrendermode() == REND_POLYMER)
Line 18045...	Line 18040...
18045	{	18040	{
18046	#ifdef USE_OPENGL	18041	#ifdef USE_OPENGL
18047	if (getrendermode() < REND_POLYMOST) return;	18042	if (getrendermode() < REND_POLYMOST) return;
18048		18043
18049	bglViewport(0,0,xres,yres);	18044	bglViewport(0,0,xres,yres);
-		18045
18050	bglMatrixMode(GL_PROJECTION);	18046	bglMatrixMode(GL_PROJECTION);
18051	bglLoadIdentity();	18047	bglLoadIdentity();
18052	bglOrtho(0,xres,yres,0,-1,1);	18048	bglOrtho(0,xres,yres,0,-1,1);
-		18049
-		18050	if (getrendermode() == REND_POLYMER)
-		18051	{
18053	bglMatrixMode(GL_MODELVIEW);	18052	bglMatrixMode(GL_MODELVIEW);
18054	bglLoadIdentity();	18053	bglLoadIdentity();
-		18054	}
18055		18055
18056	gloy1 = -1;	18056	gloy1 = -1;
18057		18057
18058	bglDisable(GL_DEPTH_TEST);	18058	bglDisable(GL_DEPTH_TEST);
18059	bglDisable(GL_TEXTURE_2D);	18059	bglDisable(GL_TEXTURE_2D);
Line 18067...	Line 18067...
18067	t->items=(hashitem_t *)Xcalloc(1, t->size sizeof(hashitem_t));	18067	t->items=(hashitem_t *)Xcalloc(1, t->size sizeof(hashitem_t));
18068	}	18068	}
18069		18069
18070	void hash_free(hashtable_t *t)	18070	void hash_free(hashtable_t *t)
18071	{	18071	{
18072	hashitem_t cur, tmp;	-
18073	int32_t i;	-
18074	int32_t num;	-
18075		-
18076	if (t->items == NULL)	18072	if (t->items == NULL)
18077	return;	18073	return;
18078	// initprintf("*free, num:%d\n",t->size);	-
-		18074
18079	i= t->size-1;	18075	int remaining = t->size - 1;
-		18076
18080	do	18077	do
18081	{	18078	{
18082	cur = t->items[i];	18079	hashitem_t *cur = t->items[remaining];
-		18080
18083	num = 0;	18081	int num = 0;
-		18082
18084	while (cur)	18083	while (cur)
18085	{	18084	{
18086	tmp = cur;	18085	hashitem_t * const tmp = cur;
18087	cur = cur->next;	18086	cur = cur->next;
18088	// initprintf("Free %4d \"%s\"\n",tmp->key,(tmp->string)?tmp->string:".");	-
-		18087
18089	if (tmp->string)	18088	if (tmp->string)
18090	{	18089	{
18091	Bfree(tmp->string);	18090	Bfree(tmp->string);
18092	tmp->string = NULL;	18091	tmp->string = NULL;
18093	}	18092	}
18094	Bfree(tmp);	18093	Bfree(tmp);
18095	num++;	18094	num++;
18096	}	18095	}
18097	// initprintf("#%4d: %3d\t",i,num);	18096	} while (--remaining >= 0);
18098	}	18097
18099	while (--i > -1);	-
18100	Bfree(t->items);	18098	Bfree(t->items);
18101	t->items = 0;	18099	t->items = 0;
18102	}	18100	}
18103		18101
18104	// djb3 algorithm	18102	// djb3 algorithm
Line 18113...	Line 18111...
18113	return h;	18111	return h;
18114	}	18112	}
18115		18113
18116	void hash_add(hashtable_t t, const char s, intptr_t key, int32_t replace)	18114	void hash_add(hashtable_t t, const char s, intptr_t key, int32_t replace)
18117	{	18115	{
18118	hashitem_t cur, prev=NULL;	-
18119	int32_t code;	-
18120		-
18121	if (EDUKE32_PREDICT_FALSE(t->items == NULL))	18116	if (EDUKE32_PREDICT_FALSE(t->items == NULL))
18122	{	18117	{
18123	initprintf("hash_add(): table not initialized!\n");	18118	initprintf("hash_add(): table not initialized!\n");
18124	return;	18119	return;
18125	}	18120	}
18126		18121
18127	code = hash_getcode(s) % t->size;	18122	uint32_t code = hash_getcode(s) % t->size;
18128	cur = t->items[code];	18123	hashitem_t *cur = t->items[code];
18129		18124
18130	if (!cur)	18125	if (!cur)
18131	{	18126	{
18132	cur = (hashitem_t *)Xcalloc(1,sizeof(hashitem_t));	18127	cur = (hashitem_t *)Xcalloc(1,sizeof(hashitem_t));
18133	cur->string = Xstrdup(s);	18128	cur->string = Xstrdup(s);
Line 18135...	Line 18130...
18135	cur->next = NULL;	18130	cur->next = NULL;
18136	t->items[code] = cur;	18131	t->items[code] = cur;
18137	return;	18132	return;
18138	}	18133	}
18139		18134
-		18135	hashitem_t *prev = NULL;
-		18136
18140	do	18137	do
18141	{	18138	{
18142	if (Bstrcmp(s,cur->string) == 0)	18139	if (Bstrcmp(s,cur->string) == 0)
18143	{	18140	{
18144	if (replace) cur->key = key;	18141	if (replace) cur->key = key;
Line 18156...	Line 18153...
18156	}	18153	}
18157		18154
18158	// delete at most once	18155	// delete at most once
18159	void hash_delete(hashtable_t t, const char s)	18156	void hash_delete(hashtable_t t, const char s)
18160	{	18157	{
18161	hashitem_t cur, prev=NULL;	-
18162	int32_t code;	-
18163		-
18164	if (t->items == NULL)	18158	if (t->items == NULL)
18165	{	18159	{
18166	initprintf("hash_delete(): table not initialized!\n");	18160	initprintf("hash_delete(): table not initialized!\n");
18167	return;	18161	return;
18168	}	18162	}
18169		18163
18170	code = hash_getcode(s) % t->size;	18164	uint32_t code = hash_getcode(s) % t->size;
18171	cur = t->items[code];	18165	hashitem_t *cur = t->items[code];
18172		18166
18173	if (!cur)	18167	if (!cur)
18174	return;	18168	return;
18175		18169
-		18170	hashitem_t *prev = NULL;
-		18171
18176	do	18172	do
18177	{	18173	{
18178	if (Bstrcmp(s,cur->string) == 0)	18174	if (Bstrcmp(s, cur->string) == 0)
18179	{	18175	{
18180	Bfree(cur->string);	18176	Bfree(cur->string);
Line 18184...	Line 18180...
18184	else	18180	else
18185	prev->next = cur->next;	18181	prev->next = cur->next;
18186		18182
18187	Bfree(cur);	18183	Bfree(cur);
18188		18184
18189	return;	18185	break;
18190	}	18186	}
18191	prev = cur;	18187	prev = cur;
18192	}	18188	}
18193	while ((cur = cur->next));	18189	while ((cur = cur->next));
18194	}	18190	}
18195		18191
18196	intptr_t hash_find(const hashtable_t t, const char s)	18192	intptr_t hash_find(const hashtable_t t, const char s)
18197	{	18193	{
18198	hashitem_t *cur;	-
18199		-
18200	if (t->items == NULL)	18194	if (t->items == NULL)
18201	{	18195	{
18202	initprintf("hash_find(): table not initialized!\n");	18196	initprintf("hash_find(): table not initialized!\n");
18203	return -1;	18197	return -1;
18204	}	18198	}
18205		18199
18206	if ((cur = t->items[hash_getcode(s) % t->size]) == NULL) return -1;	18200	hashitem_t *cur = t->items[hash_getcode(s) % t->size];
-		18201
-		18202	if (!cur)
-		18203	return -1;
18207		18204
18208	do	18205	do
18209	if (Bstrcmp(s,cur->string) == 0)	18206	if (Bstrcmp(s, cur->string) == 0)
18210	return cur->key;	18207	return cur->key;
18211	while ((cur = cur->next));	18208	while ((cur = cur->next));
Line 18213...	Line 18210...
18213	return -1;	18210	return -1;
18214	}	18211	}
18215		18212
18216	intptr_t hash_findcase(const hashtable_t t, const char s)	18213	intptr_t hash_findcase(const hashtable_t t, const char s)
18217	{	18214	{
18218	hashitem_t *cur;	-
18219		18215
18220	if (t->items == NULL)	18216	if (t->items == NULL)
18221	{	18217	{
18222	initprintf("hash_findcase(): table not initialized!\n");	18218	initprintf("hash_findcase(): table not initialized!\n");
18223	return -1;	18219	return -1;
18224	}	18220	}
18225		18221
18226	if ((cur=t->items[hash_getcode(s)%t->size]) == NULL) return -1;	18222	hashitem_t *cur = t->items[hash_getcode(s) % t->size];
-		18223
-		18224	if (!cur)
-		18225	return -1;
18227		18226
18228	do	18227	do
18229	if (Bstrcasecmp(s,cur->string) == 0)	18228	if (Bstrcasecmp(s, cur->string) == 0)
18230	return cur->key;	18229	return cur->key;
18231	while ((cur=cur->next));	18230	while ((cur = cur->next));

Subversion Repositories eduke32

(root)/polymer/eduke32/build/src/engine.c – Rev 5056 → 5071