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.273 by root, Wed Aug 20 13:30:02 2008 UTC vs.
Revision 1.296 by root, Mon Dec 21 23:52:34 2009 UTC

… …
19 19
20#ifdef _WIN32 20#ifdef _WIN32
21# undef pipe 21# undef pipe
22// microsoft vs. C 22// microsoft vs. C
23# define sqrtf(x) sqrt(x) 23# define sqrtf(x) sqrt(x)
24# define roundf(x) (int)(x)
25# define atan2f(x,y) atan2(x,y) 24# define atan2f(x,y) atan2(x,y)
26# define M_PI 3.14159265f 25# define M_PI 3.14159265f
27#endif 26#endif
28 27
29#include <assert.h> 28#include <assert.h>
… …
81#define expect_false(expr) expect ((expr) != 0, 0) 80#define expect_false(expr) expect ((expr) != 0, 0)
82#define expect_true(expr) expect ((expr) != 0, 1) 81#define expect_true(expr) expect ((expr) != 0, 1)
83 82
84#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 83#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
85 84
85/* this is used as fow flag as well, so has to have a different value */
86/* then anything that is computed by incoming darkness */
86#define FOW_DARKNESS 32 87#define FOW_DARKNESS 50
88#define DARKNESS_ADJUST(n) (n)
87 89
88#define MAP_EXTEND_X 32 90#define MAP_EXTEND_X 32
89#define MAP_EXTEND_Y 512 91#define MAP_EXTEND_Y 512
90 92
91#define MIN_FONT_HEIGHT 10 93#define MIN_FONT_HEIGHT 10
92 94
93/* mask out modifiers we are not interested in */ 95/* mask out modifiers we are not interested in */
94#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META) 96#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
97
98#define KMOD_LRAM 0x10000 // our extension
99
100#define TEXID_SPEECH 1
101#define TEXID_NOFACE 2
102#define TEXID_HIDDEN 3
95 103
96static AV *texture_av; 104static AV *texture_av;
97 105
98static struct 106static struct
99{ 107{
… …
231 int w, h; 239 int w, h;
232 float s, t; 240 float s, t;
233 uint8_t r, g, b, a; 241 uint8_t r, g, b, a;
234 tileid smoothtile; 242 tileid smoothtile;
235 uint8_t smoothlevel; 243 uint8_t smoothlevel;
244 uint8_t unused; /* set to zero on use */
236} maptex; 245} maptex;
237 246
238typedef struct { 247typedef struct {
239 uint32_t player; 248 uint32_t player;
240 tileid tile[3]; 249 tileid tile[3];
… …
527 return 0; 536 return 0;
528 537
529 return 1; 538 return 1;
530} 539}
531 540
541/******************************************************************************/
542
543/* process keyboard modifiers */
544static int
545mod_munge (int mod)
546{
547 mod &= MOD_MASK;
548
549 if (mod & (KMOD_META | KMOD_ALT))
550 mod |= KMOD_LRAM;
551
552 return mod;
553}
554
532static void 555static void
533deliantra_main () 556deliantra_main ()
534{ 557{
535 char *argv[] = { 0 }; 558 char *argv[] = { 0 };
536 call_argv ("::main", G_DISCARD | G_VOID, argv); 559 call_argv ("::main", G_DISCARD | G_VOID, argv);
537 dSP;
538} 560}
539 561
540#ifdef __MACOSX__ 562#ifdef __MACOSX__
541 /* to due surprising braindamage on the side of SDL design, we 563 /* to due surprising braindamage on the side of SDL design, we
542 * do some mind-boggling hack here: SDL requires a custom main() 564 * do some mind-boggling hack here: SDL requires a custom main()
… …
603 const_iv (SDL_USEREVENT), 625 const_iv (SDL_USEREVENT),
604 626
605 const_iv (SDL_APPINPUTFOCUS), 627 const_iv (SDL_APPINPUTFOCUS),
606 const_iv (SDL_APPMOUSEFOCUS), 628 const_iv (SDL_APPMOUSEFOCUS),
607 const_iv (SDL_APPACTIVE), 629 const_iv (SDL_APPACTIVE),
630
631
632 const_iv (SDLK_UNKNOWN),
633 const_iv (SDLK_FIRST),
634 const_iv (SDLK_BACKSPACE),
635 const_iv (SDLK_TAB),
636 const_iv (SDLK_CLEAR),
637 const_iv (SDLK_RETURN),
638 const_iv (SDLK_PAUSE),
639 const_iv (SDLK_ESCAPE),
640 const_iv (SDLK_SPACE),
641 const_iv (SDLK_EXCLAIM),
642 const_iv (SDLK_QUOTEDBL),
643 const_iv (SDLK_HASH),
644 const_iv (SDLK_DOLLAR),
645 const_iv (SDLK_AMPERSAND),
646 const_iv (SDLK_QUOTE),
647 const_iv (SDLK_LEFTPAREN),
648 const_iv (SDLK_RIGHTPAREN),
649 const_iv (SDLK_ASTERISK),
650 const_iv (SDLK_PLUS),
651 const_iv (SDLK_COMMA),
652 const_iv (SDLK_MINUS),
653 const_iv (SDLK_PERIOD),
654 const_iv (SDLK_SLASH),
655 const_iv (SDLK_0),
656 const_iv (SDLK_1),
657 const_iv (SDLK_2),
658 const_iv (SDLK_3),
659 const_iv (SDLK_4),
660 const_iv (SDLK_5),
661 const_iv (SDLK_6),
662 const_iv (SDLK_7),
663 const_iv (SDLK_8),
664 const_iv (SDLK_9),
665 const_iv (SDLK_COLON),
666 const_iv (SDLK_SEMICOLON),
667 const_iv (SDLK_LESS),
668 const_iv (SDLK_EQUALS),
669 const_iv (SDLK_GREATER),
670 const_iv (SDLK_QUESTION),
671 const_iv (SDLK_AT),
672
673 const_iv (SDLK_LEFTBRACKET),
674 const_iv (SDLK_BACKSLASH),
675 const_iv (SDLK_RIGHTBRACKET),
676 const_iv (SDLK_CARET),
677 const_iv (SDLK_UNDERSCORE),
678 const_iv (SDLK_BACKQUOTE),
679 const_iv (SDLK_DELETE),
608 680
609 const_iv (SDLK_FIRST), 681 const_iv (SDLK_FIRST),
610 const_iv (SDLK_LAST), 682 const_iv (SDLK_LAST),
611 const_iv (SDLK_KP0), 683 const_iv (SDLK_KP0),
612 const_iv (SDLK_KP1), 684 const_iv (SDLK_KP1),
… …
688 const_iv (KMOD_RMETA), 760 const_iv (KMOD_RMETA),
689 const_iv (KMOD_NUM), 761 const_iv (KMOD_NUM),
690 const_iv (KMOD_CAPS), 762 const_iv (KMOD_CAPS),
691 const_iv (KMOD_MODE), 763 const_iv (KMOD_MODE),
692 764
765 const_iv (KMOD_LRAM),
766
693 const_iv (MIX_DEFAULT_FORMAT), 767 const_iv (MIX_DEFAULT_FORMAT),
694 768
695 const_iv (SDL_INIT_TIMER), 769 const_iv (SDL_INIT_TIMER),
696 const_iv (SDL_INIT_AUDIO), 770 const_iv (SDL_INIT_AUDIO),
697 const_iv (SDL_INIT_VIDEO), 771 const_iv (SDL_INIT_VIDEO),
… …
749 823
750IV minpot (UV n) 824IV minpot (UV n)
751 825
752IV popcount (UV n) 826IV popcount (UV n)
753 827
828NV distance (NV dx, NV dy)
829 CODE:
830 RETVAL = pow (dx * dx + dy * dy, 0.5);
831 OUTPUT:
832 RETVAL
833
754void 834void
755pango_init () 835pango_init ()
756 CODE: 836 CODE:
757{ 837{
758 opengl_fontmap = pango_opengl_font_map_new (); 838 opengl_fontmap = pango_opengl_font_map_new ();
… …
884 { 964 {
885 case SDL_KEYDOWN: 965 case SDL_KEYDOWN:
886 case SDL_KEYUP: 966 case SDL_KEYUP:
887 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 967 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
888 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 968 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
889 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod & MOD_MASK), 0); 969 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
890 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState () & MOD_MASK), 0); /* current mode */ 970 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
891 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 971 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
892 break; 972 break;
893 973
894 case SDL_ACTIVEEVENT: 974 case SDL_ACTIVEEVENT:
895 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 975 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
913 x = ev.motion.x; 993 x = ev.motion.x;
914 y = ev.motion.y; 994 y = ev.motion.y;
915 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 995 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
916 } 996 }
917 997
918 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0); 998 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
919 hv_store (hv, "state", 5, newSViv (state), 0); 999 hv_store (hv, "state", 5, newSViv (state), 0);
920 hv_store (hv, "x", 1, newSViv (x), 0); 1000 hv_store (hv, "x", 1, newSViv (x), 0);
921 hv_store (hv, "y", 1, newSViv (y), 0); 1001 hv_store (hv, "y", 1, newSViv (y), 0);
922 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1002 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
923 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1003 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
… …
1139#if DEBUG 1219#if DEBUG
1140 VALGRIND_DO_LEAK_CHECK; 1220 VALGRIND_DO_LEAK_CHECK;
1141#endif 1221#endif
1142} 1222}
1143 1223
1224int
1225SvREFCNT (SV *sv)
1226 CODE:
1227 RETVAL = SvREFCNT (sv);
1228 OUTPUT:
1229 RETVAL
1230
1144MODULE = Deliantra::Client PACKAGE = DC::Font 1231MODULE = Deliantra::Client PACKAGE = DC::Font
1145 1232
1146PROTOTYPES: DISABLE 1233PROTOTYPES: DISABLE
1147 1234
1148DC::Font 1235DC::Font
… …
1577 if (ix) 1664 if (ix)
1578 { 1665 {
1579 glDisable (GL_ALPHA_TEST); 1666 glDisable (GL_ALPHA_TEST);
1580 glDisable (GL_BLEND); 1667 glDisable (GL_BLEND);
1581 } 1668 }
1669}
1670
1671void
1672draw_fow_texture (float intensity, int hidden_tex, int name1, uint8_t *data1, float s, float t, int w, int h, float blend = 0.f, int dx = 0, int dy = 0, int name2 = 0, uint8_t *data2 = data1)
1673 PROTOTYPE: @
1674 CODE:
1675{
1676 glEnable (GL_TEXTURE_2D);
1677 glEnable (GL_BLEND);
1678 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1679 glBindTexture (GL_TEXTURE_2D, name1);
1680
1681 glColor3f (intensity, intensity, intensity);
1682 glPushMatrix ();
1683 glScalef (1./3, 1./3, 1.);
1684
1685 if (blend > 0.f)
1686 {
1687 float dx3 = dx * -3.f / w;
1688 float dy3 = dy * -3.f / h;
1689 GLfloat env_color[4] = { 0., 0., 0., blend };
1690
1691 /* interpolate the two shadow textures */
1692 /* stage 0 == rgb(glcolor) + alpha(t0) */
1693 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1694
1695 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1696 gl.ActiveTexture (GL_TEXTURE1);
1697 glEnable (GL_TEXTURE_2D);
1698 glBindTexture (GL_TEXTURE_2D, name2);
1699 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1700
1701 /* rgb == rgb(glcolor) */
1702 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1703 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
1704 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1705
1706 /* alpha = interpolate t0, t1 by env_alpha */
1707 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1708
1709 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1710 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1711 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1712
1713 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1714 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1715
1716 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1717 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1718
1719 glBegin (GL_QUADS);
1720 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1721 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1722 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1723 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1724 glEnd ();
1725
1726 glDisable (GL_TEXTURE_2D);
1727 gl.ActiveTexture (GL_TEXTURE0);
1728 }
1729 else
1730 {
1731 /* simple blending of one texture, also opengl <1.3 path */
1732 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1733
1734 glBegin (GL_QUADS);
1735 glTexCoord2f (0, 0); glVertex2f (0, 0);
1736 glTexCoord2f (0, t); glVertex2f (0, h);
1737 glTexCoord2f (s, t); glVertex2f (w, h);
1738 glTexCoord2f (s, 0); glVertex2f (w, 0);
1739 glEnd ();
1740 }
1741
1742 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1743 {
1744 int x, y;
1745 int dx3 = dx * 3;
1746 int dy3 = dy * 3;
1747
1748 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1749 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1750 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1751 glTranslatef (-1., -1., 0);
1752 glBegin (GL_QUADS);
1753
1754 for (y = 1; y < h; y += 3)
1755 {
1756 int y1 = y - dy3;
1757 int y1valid = y1 >= 0 && y1 < h;
1758
1759 for (x = 1; x < w; x += 3)
1760 {
1761 int x1 = x - dx3;
1762 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1763 uint8_t h2;
1764
1765 if (y1valid && x1 >= 0 && x1 < w)
1766 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1767 else
1768 h2 = 1; /* out of range == invisible */
1769
1770 if (h1 || h2)
1771 {
1772 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1773 glColor4f (1., 1., 1., alpha);
1774
1775 glTexCoord2f (0, 0.); glVertex2i (x , y );
1776 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1777 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1778 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1779 }
1780 }
1781 }
1782 }
1783
1784 glEnd ();
1785
1786 glPopMatrix ();
1787
1788 glDisable (GL_TEXTURE_2D);
1789 glDisable (GL_BLEND);
1582} 1790}
1583 1791
1584IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1792IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1585 CODE: 1793 CODE:
1586{ 1794{
… …
1692 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1900 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1693 // use uglier nearest interpolation because linear suffers 1901 // use uglier nearest interpolation because linear suffers
1694 // from transparent color bleeding and ugly wrapping effects. 1902 // from transparent color bleeding and ugly wrapping effects.
1695 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1903 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1696} 1904}
1905
1906void
1907expire_textures (DC::Map self, int texid, int count)
1908 PPCODE:
1909 for (; texid < self->texs && count; ++texid, --count)
1910 {
1911 maptex *tex = self->tex + texid;
1912
1913 if (tex->name)
1914 {
1915 if (tex->unused)
1916 {
1917 tex->name = 0;
1918 tex->unused = 0;
1919 XPUSHs (sv_2mortal (newSViv (texid)));
1920 }
1921 else
1922 tex->unused = 1;
1923 }
1924 }
1697 1925
1698int 1926int
1699ox (DC::Map self) 1927ox (DC::Map self)
1700 ALIAS: 1928 ALIAS:
1701 oy = 1 1929 oy = 1
… …
1782 { 2010 {
1783 ext = *data++; 2011 ext = *data++;
1784 cmd = ext & 0x7f; 2012 cmd = ext & 0x7f;
1785 2013
1786 if (cmd < 4) 2014 if (cmd < 4)
1787 cell->darkness = 255 - ext * 64 + 1; 2015 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
1788 else if (cmd == 5) // health 2016 else if (cmd == 5) // health
1789 { 2017 {
1790 cell->stat_width = 1; 2018 cell->stat_width = 1;
1791 cell->stat_hp = *data++; 2019 cell->stat_hp = *data++;
1792 } 2020 }
… …
1822 cell->tile [z] = self->face2tile [face]; 2050 cell->tile [z] = self->face2tile [face];
1823 2051
1824 if (cell->tile [z]) 2052 if (cell->tile [z])
1825 { 2053 {
1826 maptex *tex = self->tex + cell->tile [z]; 2054 maptex *tex = self->tex + cell->tile [z];
2055 tex->unused = 0;
1827 if (!tex->name) 2056 if (!tex->name)
1828 av_push (missing, newSViv (cell->tile [z])); 2057 av_push (missing, newSViv (cell->tile [z]));
1829 2058
1830 if (tex->smoothtile) 2059 if (tex->smoothtile)
1831 { 2060 {
1832 maptex *smooth = self->tex + tex->smoothtile; 2061 maptex *smooth = self->tex + tex->smoothtile;
2062 smooth->unused = 0;
1833 if (!smooth->name) 2063 if (!smooth->name)
1834 av_push (missing, newSViv (tex->smoothtile)); 2064 av_push (missing, newSViv (tex->smoothtile));
1835 } 2065 }
1836 } 2066 }
1837 } 2067 }
… …
1908 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level 2138 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1909 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2139 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1910 smooth_key skey; 2140 smooth_key skey;
1911 int pl_x, pl_y; 2141 int pl_x, pl_y;
1912 maptex pl_tex; 2142 maptex pl_tex;
1913 rc_t *rc = rc_alloc (); 2143 rc_t *rc = rc_alloc ();
2144 rc_t *rc_ov = rc_alloc ();
1914 rc_key_t key; 2145 rc_key_t key;
1915 rc_array_t *arr; 2146 rc_array_t *arr, *arr_hidden;
1916 2147
1917 pl_tex.name = 0; 2148 pl_tex.name = 0;
1918 2149
1919 // thats current max. sorry. 2150 // that's current max. sorry.
1920 if (sw > 255) sw = 255; 2151 if (sw > 255) sw = 255;
1921 if (sh > 255) sh = 255; 2152 if (sh > 255) sh = 255;
1922 2153
1923 // clear key, in case of extra padding 2154 // clear key, in case of extra padding
1924 memset (&skey, 0, sizeof (skey)); 2155 memset (&skey, 0, sizeof (skey));
… …
1928 key.g = 255; 2159 key.g = 255;
1929 key.b = 255; 2160 key.b = 255;
1930 key.a = 255; 2161 key.a = 255;
1931 key.mode = GL_QUADS; 2162 key.mode = GL_QUADS;
1932 key.format = GL_T2F_V3F; 2163 key.format = GL_T2F_V3F;
1933 key.texname = -1;
1934 2164
1935 mx += self->x; 2165 mx += self->x;
1936 my += self->y; 2166 my += self->y;
1937 2167
1938 // first pass: determine smooth_max 2168 // first pass: determine smooth_max
… …
1959 2189
1960 glEnable (GL_BLEND); 2190 glEnable (GL_BLEND);
1961 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2191 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1962 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2192 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1963 2193
2194 key.texname = self->tex [TEXID_HIDDEN].name;
2195 arr_hidden = rc_array (rc_ov, &key);
2196
1964 for (z = 0; z <= 2; z++) 2197 for (z = 0; z <= 2; z++)
1965 { 2198 {
1966 memset (smooth_level, 0, sizeof (smooth_level)); 2199 memset (smooth_level, 0, sizeof (smooth_level));
2200 key.texname = -1;
1967 2201
1968 for (y = 0; y < sh; y++) 2202 for (y = 0; y < sh; y++)
1969 if (0 <= y + my && y + my < self->rows) 2203 if (0 <= y + my && y + my < self->rows)
1970 { 2204 {
1971 maprow *row = self->row + (y + my); 2205 maprow *row = self->row + (y + my);
… …
1977 tileid tile = cell->tile [z]; 2211 tileid tile = cell->tile [z];
1978 2212
1979 if (tile) 2213 if (tile)
1980 { 2214 {
1981 maptex tex = self->tex [tile]; 2215 maptex tex = self->tex [tile];
1982 int px = (x + 1) * T - tex.w; 2216 int px, py;
1983 int py = (y + 1) * T - tex.h;
1984 2217
1985 if (key.texname != tex.name) 2218 if (key.texname != tex.name)
1986 { 2219 {
2220 self->tex [tile].unused = 0;
2221
1987 if (!tex.name) 2222 if (!tex.name)
1988 tex = self->tex [2]; /* missing, replace by noface */ 2223 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1989 2224
1990 key.texname = tex.name; 2225 key.texname = tex.name;
1991 arr = rc_array (rc, &key); 2226 arr = rc_array (rc, &key);
1992 } 2227 }
2228
2229 px = (x + 1) * T - tex.w;
2230 py = (y + 1) * T - tex.h;
1993 2231
1994 if (expect_false (cell->player == player) && expect_false (z == 2)) 2232 if (expect_false (cell->player == player) && expect_false (z == 2))
1995 { 2233 {
1996 pl_x = px; 2234 pl_x = px;
1997 pl_y = py; 2235 pl_y = py;
… …
2002 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2240 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2003 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0); 2241 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
2004 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0); 2242 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
2005 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0); 2243 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2006 2244
2007 if (expect_false (cell->flags) && expect_false (z == 2))
2008 {
2009 // overlays such as the speech bubble, probably more to come
2010 if (cell->flags & 1)
2011 {
2012 maptex tex = self->tex [1];
2013 int px = x * T + T * 2 / 32;
2014 int py = y * T - T * 6 / 32;
2015
2016 if (tex.name)
2017 {
2018 if (key.texname != tex.name)
2019 {
2020 key.texname = tex.name;
2021 arr = rc_array (rc, &key);
2022 }
2023
2024 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2025 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
2026 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
2027 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
2028 }
2029 }
2030 }
2031
2032 // update smooth hash 2245 // update smooth hash
2033 if (tex.smoothtile) 2246 if (tex.smoothtile)
2034 { 2247 {
2035 skey.tile = tex.smoothtile; 2248 skey.tile = tex.smoothtile;
2036 skey.level = tex.smoothlevel; 2249 skey.level = tex.smoothlevel;
… …
2064 // corners 2277 // corners
2065 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2278 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
2066 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2279 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
2067 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2280 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
2068 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2281 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
2282 }
2283 }
2284
2285 if (expect_false (z == 2) && expect_false (cell->flags))
2286 {
2287 // overlays such as the speech bubble, probably more to come
2288 if (cell->flags & 1)
2289 {
2290 rc_key_t key_ov = key;
2291 maptex tex = self->tex [TEXID_SPEECH];
2292 rc_array_t *arr;
2293 int px = x * T + T * 2 / 32;
2294 int py = y * T - T * 6 / 32;
2295
2296 key_ov.texname = tex.name;
2297 arr = rc_array (rc_ov, &key_ov);
2298
2299 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2300 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
2301 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
2302 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
2069 } 2303 }
2070 } 2304 }
2071 } 2305 }
2072 } 2306 }
2073 2307
… …
2113 { 2347 {
2114 // this time avoiding texture state changes 2348 // this time avoiding texture state changes
2115 // save gobs of state changes. 2349 // save gobs of state changes.
2116 if (key.texname != tex.name) 2350 if (key.texname != tex.name)
2117 { 2351 {
2352 self->tex [skey->tile].unused = 0;
2353
2118 glEnd (); 2354 glEnd ();
2119 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2355 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2120 glBegin (GL_QUADS); 2356 glBegin (GL_QUADS);
2121 } 2357 }
2122 2358
… …
2168 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0); 2404 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2169 2405
2170 rc_draw (rc); 2406 rc_draw (rc);
2171 } 2407 }
2172 2408
2409 rc_draw (rc_ov);
2410 rc_clear (rc_ov);
2411
2173 glDisable (GL_BLEND); 2412 glDisable (GL_BLEND);
2174 rc_free (rc); 2413 rc_free (rc);
2414 rc_free (rc_ov);
2175 2415
2176 // top layer: overlays such as the health bar 2416 // top layer: overlays such as the health bar
2177 for (y = 0; y < sh; y++) 2417 for (y = 0; y < sh; y++)
2178 if (0 <= y + my && y + my < self->rows) 2418 if (0 <= y + my && y + my < self->rows)
2179 { 2419 {
… …
2184 { 2424 {
2185 mapcell *cell = row->col + (x + mx - row->c0); 2425 mapcell *cell = row->col + (x + mx - row->c0);
2186 2426
2187 int px = x * T; 2427 int px = x * T;
2188 int py = y * T; 2428 int py = y * T;
2429
2430 if (expect_false (cell->player == player))
2431 {
2432 px += sdx;
2433 py += sdy;
2434 }
2189 2435
2190 if (cell->stat_hp) 2436 if (cell->stat_hp)
2191 { 2437 {
2192 int width = cell->stat_width * T; 2438 int width = cell->stat_width * T;
2193 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2439 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
… …
2204 } 2450 }
2205 } 2451 }
2206} 2452}
2207 2453
2208void 2454void
2209draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data) 2455draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2210 CODE: 2456 CODE:
2211{ 2457{
2212 static float color[16][3] = { 2458 static float color[16][3] = {
2213 { 0.00F, 0.00F, 0.00F }, 2459 { 0.00f, 0.00f, 0.00f },
2214 { 1.00F, 1.00F, 1.00F }, 2460 { 1.00f, 1.00f, 1.00f },
2215 { 0.00F, 0.00F, 0.55F }, 2461 { 0.00f, 0.00f, 0.55f },
2216 { 1.00F, 0.00F, 0.00F }, 2462 { 1.00f, 0.00f, 0.00f },
2217 2463
2218 { 1.00F, 0.54F, 0.00F }, 2464 { 1.00f, 0.54f, 0.00f },
2219 { 0.11F, 0.56F, 1.00F }, 2465 { 0.11f, 0.56f, 1.00f },
2220 { 0.93F, 0.46F, 0.00F }, 2466 { 0.93f, 0.46f, 0.00f },
2221 { 0.18F, 0.54F, 0.34F }, 2467 { 0.18f, 0.54f, 0.34f },
2222 2468
2223 { 0.56F, 0.73F, 0.56F }, 2469 { 0.56f, 0.73f, 0.56f },
2224 { 0.80F, 0.80F, 0.80F }, 2470 { 0.80f, 0.80f, 0.80f },
2225 { 0.55F, 0.41F, 0.13F }, 2471 { 0.55f, 0.41f, 0.13f },
2226 { 0.99F, 0.77F, 0.26F }, 2472 { 0.99f, 0.77f, 0.26f },
2227 2473
2228 { 0.74F, 0.65F, 0.41F }, 2474 { 0.74f, 0.65f, 0.41f },
2229 2475
2230 { 0.00F, 1.00F, 1.00F }, 2476 { 0.00f, 1.00f, 1.00f },
2231 { 1.00F, 0.00F, 1.00F }, 2477 { 1.00f, 0.00f, 1.00f },
2232 { 1.00F, 1.00F, 0.00F }, 2478 { 1.00f, 1.00f, 0.00f },
2233 }; 2479 };
2234 2480
2235 int x, y; 2481 int x, y;
2236 2482
2237 glEnable (GL_TEXTURE_2D); 2483 glEnable (GL_TEXTURE_2D);
2484 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2485 * but the nvidia driver (185.18.14) mishandles alpha textures
2486 * and takes the colour from god knows where instead of using
2487 * Cp. MODULATE results in the same colour, but slightly different
2488 * alpha, but atcually gives us the correct colour with nvidia.
2489 */
2238 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2490 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2239 glEnable (GL_BLEND); 2491 glEnable (GL_BLEND);
2240 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2492 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2241 glBegin (GL_QUADS); 2493 glBegin (GL_QUADS);
2242 2494
2243 for (y = 0; y < h; y++) 2495 for (y = 0; y < h; y++)
… …
2247 2499
2248 if (m) 2500 if (m)
2249 { 2501 {
2250 float *c = color [m & 15]; 2502 float *c = color [m & 15];
2251 2503
2252 float tx1 = m & 0x40 ? 0.5 : 0.; 2504 float tx1 = m & 0x40 ? 0.5f : 0.f;
2253 float tx2 = tx1 + 0.5; 2505 float tx2 = tx1 + 0.5f;
2254 2506
2255 glColor4f (c[0], c[1], c[2], 0.75); 2507 glColor4f (c[0], c[1], c[2], 1);
2256 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2508 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2257 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2509 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2258 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2510 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2259 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2511 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2260 } 2512 }
… …
2268void 2520void
2269fow_texture (DC::Map self, int mx, int my, int sw, int sh) 2521fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2270 PPCODE: 2522 PPCODE:
2271{ 2523{
2272 int x, y; 2524 int x, y;
2273 int sw1 = sw + 2; 2525 int sw1 = sw + 2;
2274 int sh1 = sh + 2; 2526 int sh1 = sh + 2;
2275 int sh3 = sh * 3; 2527 int sh3 = sh * 3;
2276 int sw34 = (sw * 3 + 3) & ~3; 2528 int sw3 = sw * 3;
2277 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2529 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2278 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2530 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2279 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv); 2531 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2280 2532
2281 SvPOK_only (darkness3_sv); 2533 SvPOK_only (darkness3_sv);
2282 SvCUR_set (darkness3_sv, sw34 * sh3); 2534 SvCUR_set (darkness3_sv, sw3 * sh3);
2283 2535
2284 mx += self->x - 1; 2536 mx += self->x - 1;
2285 my += self->y - 1; 2537 my += self->y - 1;
2286
2287 memset (darkness1, 255 - FOW_DARKNESS, sw1 * sh1);
2288 2538
2289 for (y = 0; y < sh1; y++) 2539 for (y = 0; y < sh1; y++)
2290 if (0 <= y + my && y + my < self->rows) 2540 if (0 <= y + my && y + my < self->rows)
2291 { 2541 {
2292 maprow *row = self->row + (y + my); 2542 maprow *row = self->row + (y + my);
… …
2295 if (row->c0 <= x + mx && x + mx < row->c1) 2545 if (row->c0 <= x + mx && x + mx < row->c1)
2296 { 2546 {
2297 mapcell *cell = row->col + (x + mx - row->c0); 2547 mapcell *cell = row->col + (x + mx - row->c0);
2298 2548
2299 darkness1 [y * sw1 + x] = cell->darkness 2549 darkness1 [y * sw1 + x] = cell->darkness
2300 ? 255 - (cell->darkness - 1) 2550 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2301 : 255 - FOW_DARKNESS; 2551 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2302 } 2552 }
2303 } 2553 }
2304 2554
2305 for (y = 0; y < sh; ++y) 2555 for (y = 0; y < sh; ++y)
2306 for (x = 0; x < sw; ++x) 2556 for (x = 0; x < sw; ++x)
… …
2325 2575
2326 uint8_t r13 = (d13 + d23 + d12) / 3; 2576 uint8_t r13 = (d13 + d23 + d12) / 3;
2327 uint8_t r23 = d23; 2577 uint8_t r23 = d23;
2328 uint8_t r33 = (d23 + d33 + d32) / 3; 2578 uint8_t r33 = (d23 + d33 + d32) / 3;
2329 2579
2330 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2580 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2331 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2581 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2332 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2582 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2333 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2583 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2334 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22); 2584 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2335 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2585 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2336 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2586 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2337 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2587 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2338 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2588 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2339 } 2589 }
2340 2590
2341 free (darkness1); 2591 free (darkness1);
2342 2592
2343 EXTEND (SP, 3); 2593 EXTEND (SP, 3);
2344 PUSHs (sv_2mortal (newSViv (sw34))); 2594 PUSHs (sv_2mortal (newSViv (sw3)));
2345 PUSHs (sv_2mortal (newSViv (sh3))); 2595 PUSHs (sv_2mortal (newSViv (sh3)));
2346 PUSHs (darkness3_sv); 2596 PUSHs (darkness3_sv);
2347} 2597}
2348 2598
2349SV * 2599SV *
… …
2606void 2856void
2607set_position_r (DC::Channel self, int dx, int dy, int maxdistance) 2857set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2608 CODE: 2858 CODE:
2609{ 2859{
2610 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2860 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2611 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2861 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2612 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2862 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2613} 2863}
2614 2864
2615void 2865void
2616set_reverse_stereo (DC::Channel self, int flip) 2866set_reverse_stereo (DC::Channel self, int flip)
… …
2719 } *civ, const_iv[] = { 2969 } *civ, const_iv[] = {
2720# define const_iv(name) { # name, (IV)name } 2970# define const_iv(name) { # name, (IV)name }
2721 const_iv (GL_VENDOR), 2971 const_iv (GL_VENDOR),
2722 const_iv (GL_VERSION), 2972 const_iv (GL_VERSION),
2723 const_iv (GL_EXTENSIONS), 2973 const_iv (GL_EXTENSIONS),
2974 const_iv (GL_MAX_TEXTURE_UNITS),
2724 const_iv (GL_COLOR_MATERIAL), 2975 const_iv (GL_COLOR_MATERIAL),
2725 const_iv (GL_SMOOTH), 2976 const_iv (GL_SMOOTH),
2726 const_iv (GL_FLAT), 2977 const_iv (GL_FLAT),
2727 const_iv (GL_DITHER), 2978 const_iv (GL_DITHER),
2728 const_iv (GL_BLEND), 2979 const_iv (GL_BLEND),
… …
2740 const_iv (GL_ZERO), 2991 const_iv (GL_ZERO),
2741 const_iv (GL_SRC_ALPHA), 2992 const_iv (GL_SRC_ALPHA),
2742 const_iv (GL_DST_ALPHA), 2993 const_iv (GL_DST_ALPHA),
2743 const_iv (GL_ONE_MINUS_SRC_ALPHA), 2994 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2744 const_iv (GL_ONE_MINUS_DST_ALPHA), 2995 const_iv (GL_ONE_MINUS_DST_ALPHA),
2996 const_iv (GL_SRC_COLOR),
2997 const_iv (GL_DST_COLOR),
2998 const_iv (GL_ONE_MINUS_SRC_COLOR),
2999 const_iv (GL_ONE_MINUS_DST_COLOR),
2745 const_iv (GL_SRC_ALPHA_SATURATE), 3000 const_iv (GL_SRC_ALPHA_SATURATE),
2746 const_iv (GL_RGB), 3001 const_iv (GL_RGB),
2747 const_iv (GL_RGBA), 3002 const_iv (GL_RGBA),
2748 const_iv (GL_RGBA4), 3003 const_iv (GL_RGBA4),
2749 const_iv (GL_RGBA8), 3004 const_iv (GL_RGBA8),
… …
2817 const_iv (GL_NICEST), 3072 const_iv (GL_NICEST),
2818 const_iv (GL_V2F), 3073 const_iv (GL_V2F),
2819 const_iv (GL_V3F), 3074 const_iv (GL_V3F),
2820 const_iv (GL_T2F_V3F), 3075 const_iv (GL_T2F_V3F),
2821 const_iv (GL_T2F_N3F_V3F), 3076 const_iv (GL_T2F_N3F_V3F),
3077 const_iv (GL_FUNC_ADD),
3078 const_iv (GL_FUNC_SUBTRACT),
3079 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2822# undef const_iv 3080# undef const_iv
2823 }; 3081 };
2824 3082
2825 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3083 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2826 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3084 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
… …
2833disable_GL_EXT_blend_func_separate () 3091disable_GL_EXT_blend_func_separate ()
2834 CODE: 3092 CODE:
2835 gl.BlendFuncSeparate = 0; 3093 gl.BlendFuncSeparate = 0;
2836 gl.BlendFuncSeparateEXT = 0; 3094 gl.BlendFuncSeparateEXT = 0;
2837 3095
3096void
3097apple_nvidia_bug (int enable)
3098
2838char * 3099char *
2839gl_vendor () 3100gl_vendor ()
2840 CODE: 3101 CODE:
2841 RETVAL = (char *)glGetString (GL_VENDOR); 3102 RETVAL = (char *)glGetString (GL_VENDOR);
2842 OUTPUT: 3103 OUTPUT:
… …
2891 3152
2892void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3153void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2893 CODE: 3154 CODE:
2894 gl_BlendFuncSeparate (sa, da, saa, daa); 3155 gl_BlendFuncSeparate (sa, da, saa, daa);
2895 3156
3157# void glBlendEquation (int se)
3158
2896void glDepthMask (int flag) 3159void glDepthMask (int flag)
2897 3160
2898void glLogicOp (int opcode) 3161void glLogicOp (int opcode)
2899 3162
2900void glColorMask (int red, int green, int blue, int alpha) 3163void glColorMask (int red, int green, int blue, int alpha)
… …
2934void glRotate (float angle, float x, float y, float z) 3197void glRotate (float angle, float x, float y, float z)
2935 CODE: 3198 CODE:
2936 glRotatef (angle, x, y, z); 3199 glRotatef (angle, x, y, z);
2937 3200
2938void glColor (float r, float g, float b, float a = 1.0) 3201void glColor (float r, float g, float b, float a = 1.0)
3202 PROTOTYPE: @
2939 ALIAS: 3203 ALIAS:
2940 glColor_premultiply = 1 3204 glColor_premultiply = 1
2941 CODE: 3205 CODE:
2942 if (ix) 3206 if (ix)
2943 { 3207 {
… …
3048void glNewList (int list, int mode = GL_COMPILE) 3312void glNewList (int list, int mode = GL_COMPILE)
3049 3313
3050void glEndList () 3314void glEndList ()
3051 3315
3052void glCallList (int list) 3316void glCallList (int list)
3317
3318void c_init ()
3319 CODE:
3320 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3321 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3053 3322
3054MODULE = Deliantra::Client PACKAGE = DC::UI::Base 3323MODULE = Deliantra::Client PACKAGE = DC::UI::Base
3055 3324
3056PROTOTYPES: DISABLE 3325PROTOTYPES: DISABLE
3057 3326

Diff Legend

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