ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/Deliantra-Client/Client.xs
(Generate patch)

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.176 by root, Tue Apr 10 09:39:48 2007 UTC vs.
Revision 1.185 by root, Sat Apr 21 09:21:03 2007 UTC

… …
345} smooth_key; 345} smooth_key;
346 346
347static void 347static void
348smooth_or_bits (HV *hv, smooth_key *key, IV bits) 348smooth_or_bits (HV *hv, smooth_key *key, IV bits)
349{ 349{
350 SV **sv = hv_fetch (hv, (char *)key, sizeof (key), 1); 350 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
351 351
352 if (SvIOK (*sv)) 352 if (SvIOK (*sv))
353 SvIV_set (*sv, SvIVX (*sv) | bits); 353 SvIV_set (*sv, SvIVX (*sv) | bits);
354 else 354 else
355 sv_setiv (*sv, bits); 355 sv_setiv (*sv, bits);
… …
400 400
401/* SDL should provide this, really. */ 401/* SDL should provide this, really. */
402#define SDLK_MODIFIER_MIN 300 402#define SDLK_MODIFIER_MIN 300
403#define SDLK_MODIFIER_MAX 314 403#define SDLK_MODIFIER_MAX 314
404 404
405static AV *texture_av;
406
405MODULE = CFPlus PACKAGE = CFPlus 407MODULE = CFPlus PACKAGE = CFPlus
406 408
407PROTOTYPES: ENABLE 409PROTOTYPES: ENABLE
408 410
409BOOT: 411BOOT:
410{ 412{
413 texture_av = newAV ();
414 AvREAL_off (texture_av);
415
411 HV *stash = gv_stashpv ("CFPlus", 1); 416 HV *stash = gv_stashpv ("CFPlus", 1);
412 static const struct { 417 static const struct {
413 const char *name; 418 const char *name;
414 IV iv; 419 IV iv;
415 } *civ, const_iv[] = { 420 } *civ, const_iv[] = {
… …
701Mix_AllocateChannels (int numchans = -1) 706Mix_AllocateChannels (int numchans = -1)
702 707
703void 708void
704lowdelay (int fd, int val = 1) 709lowdelay (int fd, int val = 1)
705 CODE: 710 CODE:
706#ifndef _WIN32
707 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 711 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
708#endif
709 712
710void 713void
711win32_proxy_info () 714win32_proxy_info ()
712 PPCODE: 715 PPCODE:
713{ 716{
… …
1462 } 1465 }
1463 else if (cmd == 6) // monster width 1466 else if (cmd == 6) // monster width
1464 cell->stat_width = *data++ + 1; 1467 cell->stat_width = *data++ + 1;
1465 else if (cmd == 0x47) 1468 else if (cmd == 0x47)
1466 { 1469 {
1467 if (*data == 8) 1470 if (*data == 4)
1468 ; // decode player uuid 1471 ; // decode player count
1469 1472
1470 data += *data + 1; 1473 data += *data + 1;
1471 } 1474 }
1472 else if (cmd == 8) // cell flags 1475 else if (cmd == 8) // cell flags
1473 cell->flags = *data++; 1476 cell->flags = *data++;
… …
1567draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T) 1570draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1568 CODE: 1571 CODE:
1569{ 1572{
1570 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ()); 1573 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1571 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level 1574 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1572 uint8_t smooth_max[256][256]; 1575 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1573 smooth_key skey; 1576 smooth_key skey;
1574 int x, y, z; 1577 int x, y, z;
1575 int last_name; 1578 int last_name;
1576 1579
1577 // thats current max. sorry. 1580 // thats current max. sorry.
… …
1597 1600
1598 // first pass: determine smooth_max 1601 // first pass: determine smooth_max
1599 // rather ugly, if you ask me 1602 // rather ugly, if you ask me
1600 // could also be stored inside mapcell and updated on change 1603 // could also be stored inside mapcell and updated on change
1601 memset (smooth_max, 0, sizeof (smooth_max)); 1604 memset (smooth_max, 0, sizeof (smooth_max));
1605 memset (smooth_level, 0, sizeof (smooth_level));
1602 1606
1603 for (y = 0; y < sh; y++) 1607 for (y = 0; y < sh; y++)
1604 if (0 <= y + my && y + my < self->rows) 1608 if (0 <= y + my && y + my < self->rows)
1605 { 1609 {
1606 maprow *row = self->row + (y + my); 1610 maprow *row = self->row + (y + my);
… …
1608 for (x = 0; x < sw; x++) 1612 for (x = 0; x < sw; x++)
1609 if (row->c0 <= x + mx && x + mx < row->c1) 1613 if (row->c0 <= x + mx && x + mx < row->c1)
1610 { 1614 {
1611 mapcell *cell = row->col + (x + mx - row->c0); 1615 mapcell *cell = row->col + (x + mx - row->c0);
1612 1616
1613 for (z = 0; z <= 2; z++)
1614 {
1615 uint8_t level = self->tex [cell->tile [z]].smoothlevel;
1616 if (level > smooth_max [x + 1][y + 1])
1617 smooth_max [x + 1][y + 1] = level; 1617 smooth_max[x + 1][y + 1] =
1618 } 1618 MAX (self->tex [cell->tile [0]].smoothlevel,
1619 MAX (self->tex [cell->tile [1]].smoothlevel,
1620 self->tex [cell->tile [2]].smoothlevel));
1619 } 1621 }
1620 } 1622 }
1621 1623
1622 for (z = 0; z <= 2; z++) 1624 for (z = 0; z <= 2; z++)
1623 { 1625 {
1624 memset (smooth_level, 0, sizeof (smooth_level));
1625
1626 for (y = 0; y < sh; y++) 1626 for (y = 0; y < sh; y++)
1627 if (0 <= y + my && y + my < self->rows) 1627 if (0 <= y + my && y + my < self->rows)
1628 { 1628 {
1629 maprow *row = self->row + (y + my); 1629 maprow *row = self->row + (y + my);
1630 1630
… …
1685 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 1685 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1686 1686
1687 // add bits to current tile and all neighbours. skey.x|y is 1687 // add bits to current tile and all neighbours. skey.x|y is
1688 // shifted +1|+1 so we always stay positive. 1688 // shifted +1|+1 so we always stay positive.
1689 1689
1690 // bits is ___n cccc CCCC bbbb
1691 // n do not draw borders&corners
1692 // c draw these corners, but...
1693 // C ... not these
1694 // b draw these borders
1695
1696 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1697 // ┃· ·· ·┃ ━━
1698
1699 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1700 // ·· ·· ·┏ ┓·
1701
1690 // full tile 1702 // full tile
1691 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 1703 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1692 1704
1693 // borders 1705 // borders
1694 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0031); 1706 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1695 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0092); 1707 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1696 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 1708 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1697 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 1709 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1698 1710
1699 // corners 1711 // corners
1700 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 1712 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
… …
1703 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 1715 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1704 } 1716 }
1705 } 1717 }
1706 } 1718 }
1707 } 1719 }
1720 }
1708 1721
1709 // go through all smoothlevels, lowest to highest, then draw 1722 // go through all smoothlevels, lowest to highest, then draw.
1710 // this is basically counting sort 1723 // this is basically counting sort
1724 {
1725 int w, b;
1726
1727 for (w = 0; w < 256 / 32; ++w)
1711 { 1728 {
1712 int w, b;
1713
1714 for (w = 0; w < 256 / 32; ++w)
1715 {
1716 uint32_t smask = smooth_level [w]; 1729 uint32_t smask = smooth_level [w];
1717 if (smask) 1730 if (smask)
1718 for (b = 0; b < 32; ++b) 1731 for (b = 0; b < 32; ++b)
1719 if (smask & (((uint32_t)1) << b)) 1732 if (smask & (((uint32_t)1) << b))
1733 {
1734 int level = (w << 5) | b;
1735 HE *he;
1736
1737 hv_iterinit (smooth);
1738 while ((he = hv_iternext (smooth)))
1720 { 1739 {
1721 int level = (w << 5) | b; 1740 smooth_key *skey = (smooth_key *)HeKEY (he);
1722 HE *he; 1741 IV bits = SvIVX (HeVAL (he));
1723 1742
1724 hv_iterinit (smooth); 1743 if (!(bits & 0x1000)
1725 while ((he = hv_iternext (smooth))) 1744 && skey->level == level
1745 && level >= smooth_max [skey->x][skey->y])
1726 { 1746 {
1727 smooth_key *skey = (smooth_key *)HeKEY (he); 1747 maptex tex = self->tex [skey->tile];
1728 IV bits = SvIVX (HeVAL (he)); 1748 int px = (((int)skey->x) - 1) * T;
1729 1749 int py = (((int)skey->y) - 1) * T;
1730 // bits is ___n cccc CCCC bbbb
1731 // n do not draw borders&corners
1732 // c draw these corners, but...
1733 // C ... not these
1734 // b draw these borders
1735
1736 if (!(bits & 0x1000) 1750 int border = bits & 15;
1737 && skey->level == level 1751 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1738 && level >= smooth_max [skey->x][skey->y]) 1752 float dx = tex.s * .0625f; // 16 images/row
1753 float dy = tex.t * .5f ; // 2 images/column
1754
1755 // this time naively avoiding texture state changes
1756 // save gobs of state changes.
1757 if (last_name != tex.name)
1739 { 1758 {
1740 maptex tex = self->tex [skey->tile];
1741 int px = (((int)skey->x) - 1) * T;
1742 int py = (((int)skey->y) - 1) * T;
1743 int border = bits & 15;
1744 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1745 float dx = tex.s * .0625f; // 16 images/row
1746 float dy = tex.t * .5f ; // 2 images/column
1747
1748 // this time naively avoiding texture state changes
1749 // save gobs of state changes.
1750 if (last_name != tex.name)
1751 {
1752 if (!tex.name) 1759 if (!tex.name)
1753 continue; // smoothing not yet available 1760 continue; // smoothing not yet available
1754 1761
1755 glEnd (); 1762 glEnd ();
1756 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 1763 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1757 glBegin (GL_QUADS); 1764 glBegin (GL_QUADS);
1758 } 1765 }
1759 1766
1760 if (border) 1767 if (border)
1761 { 1768 {
1762 float ox = border * dx; 1769 float ox = border * dx;
1763 1770
1764 glTexCoord2f (ox , 0.f ); glVertex2f (px , py ); 1771 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1765 glTexCoord2f (ox , dy ); glVertex2f (px , py + T); 1772 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1766 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T); 1773 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1767 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py ); 1774 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1768 } 1775 }
1769 1776
1770 if (corner) 1777 if (corner)
1771 { 1778 {
1772 float ox = corner * dx; 1779 float ox = corner * dx;
1773 1780
1774 glTexCoord2f (ox , dy ); glVertex2f (px , py ); 1781 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1775 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T); 1782 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1776 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T); 1783 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1777 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py ); 1784 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1778 }
1779 } 1785 }
1780 } 1786 }
1781 } 1787 }
1782 } 1788 }
1783 } 1789 }
1784
1785 hv_clear (smooth);
1786 } 1790 }
1791
1792 //hv_clear (smooth);
1787 1793
1788 glEnd (); 1794 glEnd ();
1789 1795
1790 glDisable (GL_TEXTURE_2D); 1796 glDisable (GL_TEXTURE_2D);
1791 glDisable (GL_BLEND); 1797 glDisable (GL_BLEND);
… …
2368 2374
2369int glGenTexture () 2375int glGenTexture ()
2370 CODE: 2376 CODE:
2371{ 2377{
2372 GLuint name; 2378 GLuint name;
2379 if (AvFILL (texture_av) >= 0)
2380 name = (GLuint)av_pop (texture_av);
2381 else
2373 glGenTextures (1, &name); 2382 glGenTextures (1, &name);
2374 RETVAL = name; 2383 RETVAL = name;
2375} 2384}
2376 OUTPUT: 2385 OUTPUT:
2377 RETVAL 2386 RETVAL
2378 2387
2379void glDeleteTexture (int name) 2388void glDeleteTexture (int name)
2380 CODE: 2389 CODE:
2381{ 2390{
2382 GLuint name_ = name; 2391 /* make a half-assed attempt at returning the memory used by the texture */
2392 /* textures are frequently being reused by cfplus anyway */
2393 glBindTexture (GL_TEXTURE_2D, name);
2394 glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);
2395 av_push (texture_av, (SV *)name);
2383 glDeleteTextures (1, &name_); 2396 /*glDeleteTextures (1, &name_);*/
2384} 2397}
2385 2398
2386int glGenList () 2399int glGenList ()
2387 CODE: 2400 CODE:
2388 RETVAL = glGenLists (1); 2401 RETVAL = glGenLists (1);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines