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.192 by root, Fri Apr 27 21:27:51 2007 UTC vs.
Revision 1.297 by root, Tue Dec 22 00:08:11 2009 UTC

6# include <wininet.h> 6# include <wininet.h>
7# pragma warning(disable:4244) 7# pragma warning(disable:4244)
8# pragma warning(disable:4761) 8# pragma warning(disable:4761)
9#endif 9#endif
10 10
11//#define DEBUG 1
12#if DEBUG
13# include <valgrind/memcheck.h>
14#endif
15
11#include "EXTERN.h" 16#include "EXTERN.h"
12#include "perl.h" 17#include "perl.h"
13#include "XSUB.h" 18#include "XSUB.h"
14 19
15#ifdef _WIN32 20#ifdef _WIN32
16# undef pipe 21# undef pipe
22// microsoft vs. C
23# define sqrtf(x) sqrt(x)
24# define atan2f(x,y) atan2(x,y)
25# define M_PI 3.14159265f
17#endif 26#endif
18 27
19#include <assert.h> 28#include <assert.h>
20#include <math.h> 29#include <math.h>
21#include <string.h> 30#include <string.h>
22#include <stdio.h> 31#include <stdio.h>
23#include <stdlib.h> 32#include <stdlib.h>
24 33
34#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
35
25#include <SDL.h> 36#include <SDL.h>
37#include <SDL_thread.h>
26#include <SDL_endian.h> 38#include <SDL_endian.h>
27#include <SDL_image.h> 39#include <SDL_image.h>
28#include <SDL_mixer.h> 40#include <SDL_mixer.h>
29#include <SDL_opengl.h> 41#include <SDL_opengl.h>
30 42
43/* work around os x broken headers */
44#ifdef __MACOSX__
45typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
46#endif
47
31#define PANGO_ENABLE_BACKEND 48#define PANGO_ENABLE_BACKEND
32#define G_DISABLE_CAST_CHECKS 49#define G_DISABLE_CAST_CHECKS
33 50
34#include <glib/gmacros.h> 51#include <glib/gmacros.h>
35 52
36#include <pango/pango.h> 53#include <pango/pango.h>
54
55#ifndef PANGO_VERSION_CHECK
56# define PANGO_VERSION_CHECK(a,b,c) 0
57#endif
58
59#if !PANGO_VERSION_CHECK (1, 15, 2)
60# define pango_layout_get_line_readonly pango_layout_get_line
61# define pango_layout_get_lines_readonly pango_layout_get_lines
62# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line
63# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run
64#endif
37 65
38#ifndef _WIN32 66#ifndef _WIN32
39# include <sys/types.h> 67# include <sys/types.h>
40# include <sys/socket.h> 68# include <sys/socket.h>
41# include <netinet/in.h> 69# include <netinet/in.h>
42# include <netinet/tcp.h> 70# include <netinet/tcp.h>
43# include <inttypes.h> 71# include <inttypes.h>
44#endif 72#endif
45 73
74#if __GNUC__ >= 4
75# define expect(expr,value) __builtin_expect ((expr),(value))
76#else
77# define expect(expr,value) (expr)
78#endif
79
80#define expect_false(expr) expect ((expr) != 0, 0)
81#define expect_true(expr) expect ((expr) != 0, 1)
82
46#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 83#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
47 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 */
48#define FOW_DARKNESS 32 87#define FOW_DARKNESS 50
88#define DARKNESS_ADJUST(n) (n)
49 89
50#define MAP_EXTEND_X 32 90#define MAP_EXTEND_X 32
51#define MAP_EXTEND_Y 512 91#define MAP_EXTEND_Y 512
52 92
53#define MIN_FONT_HEIGHT 10 93#define MIN_FONT_HEIGHT 10
54 94
55#if 0 95/* mask out modifiers we are not interested in */
56# define PARACHUTE SDL_INIT_NOPARACHUTE 96#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
57#else 97
58# define PARACHUTE 0 98#define KMOD_LRAM 0x10000 // our extension
59#endif 99
100#define TEXID_SPEECH 1
101#define TEXID_NOFACE 2
60 102
61static AV *texture_av; 103static AV *texture_av;
62 104
63static struct 105static struct
64{ 106{
101 av_push (texture_av, (SV *)(size_t)name); 143 av_push (texture_av, (SV *)(size_t)name);
102 glDeleteTextures (1, &name); 144 glDeleteTextures (1, &name);
103} 145}
104 146
105#include "texcache.c" 147#include "texcache.c"
148#include "rendercache.c"
106 149
107#include "pango-font.c" 150#include "pango-font.c"
108#include "pango-fontmap.c" 151#include "pango-fontmap.c"
109#include "pango-render.c" 152#include "pango-render.c"
110 153
154typedef IV DC__Channel;
155typedef SDL_RWops *DC__RW;
111typedef Mix_Chunk *CFPlus__MixChunk; 156typedef Mix_Chunk *DC__MixChunk;
112typedef Mix_Music *CFPlus__MixMusic; 157typedef Mix_Music *DC__MixMusic;
113 158
114typedef PangoFontDescription *CFPlus__Font; 159typedef PangoFontDescription *DC__Font;
115 160
116static int 161static int
117shape_attr_p (PangoLayoutRun *run) 162shape_attr_p (PangoLayoutRun *run)
118{ 163{
119 GSList *attrs = run->item->analysis.extra_attrs; 164 GSList *attrs = run->item->analysis.extra_attrs;
133 178
134typedef struct cf_layout { 179typedef struct cf_layout {
135 PangoLayout *pl; 180 PangoLayout *pl;
136 float r, g, b, a; // default color for rgba mode 181 float r, g, b, a; // default color for rgba mode
137 int base_height; 182 int base_height;
138 CFPlus__Font font; 183 DC__Font font;
184 rc_t *rc;
139} *CFPlus__Layout; 185} *DC__Layout;
140 186
141static CFPlus__Font default_font; 187static DC__Font default_font;
142static PangoContext *opengl_context; 188static PangoContext *opengl_context;
143static PangoFontMap *opengl_fontmap; 189static PangoFontMap *opengl_fontmap;
144 190
145static void 191static void
146substitute_func (FcPattern *pattern, gpointer data) 192substitute_func (FcPattern *pattern, gpointer data)
151#endif 197#endif
152 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 198 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
153} 199}
154 200
155static void 201static void
156layout_update_font (CFPlus__Layout self) 202layout_update_font (DC__Layout self)
157{ 203{
158 /* use a random scale factor to account for unknown descenders, 0.8 works 204 /* use a random scale factor to account for unknown descenders, 0.8 works
159 * reasonably well with bitstream vera 205 * reasonably well with dejavu/bistream fonts
160 */ 206 */
161 PangoFontDescription *font = self->font ? self->font : default_font; 207 PangoFontDescription *font = self->font ? self->font : default_font;
162 208
163 pango_font_description_set_absolute_size (font, 209 pango_font_description_set_absolute_size (font,
164 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 210 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
165 211
166 pango_layout_set_font_description (self->pl, font); 212 pango_layout_set_font_description (self->pl, font);
167} 213}
168 214
169static void 215static void
170layout_get_pixel_size (CFPlus__Layout self, int *w, int *h) 216layout_get_pixel_size (DC__Layout self, int *w, int *h)
171{ 217{
172 PangoRectangle rect; 218 PangoRectangle rect;
173 219
174 // get_pixel_* wrongly rounds down 220 // get_pixel_* wrongly rounds down
175 pango_layout_get_extents (self->pl, 0, &rect); 221 pango_layout_get_extents (self->pl, 0, &rect);
186 232
187typedef uint16_t tileid; 233typedef uint16_t tileid;
188typedef uint16_t faceid; 234typedef uint16_t faceid;
189 235
190typedef struct { 236typedef struct {
191 int name; 237 GLuint name;
192 int w, h; 238 int w, h;
193 float s, t; 239 float s, t;
194 uint8_t r, g, b, a; 240 uint8_t r, g, b, a;
195 tileid smoothtile; 241 tileid smoothtile;
196 uint8_t smoothlevel; 242 uint8_t smoothlevel;
243 uint8_t unused; /* set to zero on use */
197} maptex; 244} maptex;
198 245
199typedef struct { 246typedef struct {
200 uint32_t player; 247 uint32_t player;
201 tileid tile[3]; 248 tileid tile[3];
214 int faces; tileid *face2tile; // [faceid] 261 int faces; tileid *face2tile; // [faceid]
215 int texs; maptex *tex; // [tileid] 262 int texs; maptex *tex; // [tileid]
216 263
217 int32_t rows; 264 int32_t rows;
218 maprow *row; 265 maprow *row;
219} *CFPlus__Map; 266} *DC__Map;
220 267
221static char * 268static char *
222prepend (char *ptr, int sze, int inc) 269prepend (char *ptr, int sze, int inc)
223{ 270{
224 char *p; 271 char *p;
262 self->texs *= 2; 309 self->texs *= 2;
263 } 310 }
264} 311}
265 312
266static maprow * 313static maprow *
267map_get_row (CFPlus__Map self, int y) 314map_get_row (DC__Map self, int y)
268{ 315{
269 if (0 > y) 316 if (0 > y)
270 { 317 {
271 int extend = - y + MAP_EXTEND_Y; 318 int extend = - y + MAP_EXTEND_Y;
272 Prepend (maprow, self->row, self->rows, extend); 319 Prepend (maprow, self->row, self->rows, extend);
310 357
311 return row->col + (x - row->c0); 358 return row->col + (x - row->c0);
312} 359}
313 360
314static mapcell * 361static mapcell *
315map_get_cell (CFPlus__Map self, int x, int y) 362map_get_cell (DC__Map self, int x, int y)
316{ 363{
317 return row_get_cell (map_get_row (self, y), x); 364 return row_get_cell (map_get_row (self, y), x);
318} 365}
319 366
320static void 367static void
321map_clear (CFPlus__Map self) 368map_clear (DC__Map self)
322{ 369{
323 int r; 370 int r;
324 371
325 for (r = 0; r < self->rows; r++) 372 for (r = 0; r < self->rows; r++)
326 Safefree (self->row[r].col); 373 Safefree (self->row[r].col);
333 self->oy = 0; 380 self->oy = 0;
334 self->row = 0; 381 self->row = 0;
335 self->rows = 0; 382 self->rows = 0;
336} 383}
337 384
385#define CELL_CLEAR(cell) \
386 do { \
387 if ((cell)->player) \
388 (cell)->tile [2] = 0; \
389 (cell)->darkness = 0; \
390 (cell)->stat_hp = 0; \
391 (cell)->flags = 0; \
392 (cell)->player = 0; \
393 } while (0)
394
338static void 395static void
339map_blank (CFPlus__Map self, int x0, int y0, int w, int h) 396map_blank (DC__Map self, int x0, int y0, int w, int h)
340{ 397{
341 int x, y; 398 int x, y;
342 maprow *row; 399 maprow *row;
343 mapcell *cell; 400 mapcell *cell;
344 401
356 if (x >= row->c1) 413 if (x >= row->c1)
357 break; 414 break;
358 415
359 cell = row->col + x - row->c0; 416 cell = row->col + x - row->c0;
360 417
361 cell->darkness = 0; 418 CELL_CLEAR (cell);
362 cell->stat_hp = 0;
363 cell->flags = 0;
364 cell->player = 0;
365 } 419 }
366 } 420 }
367} 421}
368 422
369typedef struct { 423typedef struct {
423 n |= n >> 16; 477 n |= n >> 16;
424 478
425 return n + 1; 479 return n + 1;
426} 480}
427 481
482static unsigned int
483popcount (unsigned int n)
484{
485 n -= (n >> 1) & 0x55555555U;
486 n = ((n >> 2) & 0x33333333U) + (n & 0x33333333U);
487 n = ((n >> 4) + n) & 0x0f0f0f0fU;
488 n *= 0x01010101U;
489
490 return n >> 24;
491}
492
428/* SDL should provide this, really. */ 493/* SDL should provide this, really. */
429#define SDLK_MODIFIER_MIN 300 494#define SDLK_MODIFIER_MIN 300
430#define SDLK_MODIFIER_MAX 314 495#define SDLK_MODIFIER_MAX 314
431 496
432MODULE = CFPlus PACKAGE = CFPlus 497/******************************************************************************/
498
499static GV *draw_x_gv, *draw_y_gv, *draw_w_gv, *draw_h_gv;
500static GV *hover_gv;
501
502static int
503within_widget (SV *widget, NV x, NV y)
504{
505 HV *self;
506 SV **svp;
507 NV wx, ww, wy, wh;
508
509 if (!SvROK (widget))
510 return 0;
511
512 self = (HV *)SvRV (widget);
513
514 if (SvTYPE (self) != SVt_PVHV)
515 return 0;
516
517 svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
518 if (y < wy)
519 return 0;
520
521 svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
522 if (y >= wy + wh)
523 return 0;
524
525 svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
526 if (x < wx)
527 return 0;
528
529 svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
530 if (x >= wx + ww)
531 return 0;
532
533 svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
534 if (!svp || !SvTRUE (*svp))
535 return 0;
536
537 return 1;
538}
539
540/******************************************************************************/
541
542/* process keyboard modifiers */
543static int
544mod_munge (int mod)
545{
546 mod &= MOD_MASK;
547
548 if (mod & (KMOD_META | KMOD_ALT))
549 mod |= KMOD_LRAM;
550
551 return mod;
552}
553
554static void
555deliantra_main ()
556{
557 char *argv[] = { 0 };
558 call_argv ("::main", G_DISCARD | G_VOID, argv);
559}
560
561#ifdef __MACOSX__
562 /* to due surprising braindamage on the side of SDL design, we
563 * do some mind-boggling hack here: SDL requires a custom main()
564 * on OS X, so... we provide one and call the original main(), which,
565 * due to share dlibrary magic, calls -lSDLmain's main, not perl's main,
566 * and which calls our main (== SDL_main) back.
567 */
568 extern C_LINKAGE int
569 main (int argc, char *argv[])
570 {
571 deliantra_main ();
572 }
573
574 #undef main
575
576 extern C_LINKAGE int main (int argc, char *argv[]);
577
578 static void
579 SDL_braino (void)
580 {
581 char *argv[] = { "deliantra client", 0 };
582 (main) (1, argv);
583 }
584#else
585 static void
586 SDL_braino (void)
587 {
588 deliantra_main ();
589 }
590#endif
591
592MODULE = Deliantra::Client PACKAGE = DC
433 593
434PROTOTYPES: ENABLE 594PROTOTYPES: ENABLE
435 595
436BOOT: 596BOOT:
437{ 597{
438 HV *stash = gv_stashpv ("CFPlus", 1); 598 HV *stash = gv_stashpv ("DC", 1);
439 static const struct { 599 static const struct {
440 const char *name; 600 const char *name;
441 IV iv; 601 IV iv;
442 } *civ, const_iv[] = { 602 } *civ, const_iv[] = {
443# define const_iv(name) { # name, (IV)name } 603# define const_iv(name) { # name, (IV)name }
465 625
466 const_iv (SDL_APPINPUTFOCUS), 626 const_iv (SDL_APPINPUTFOCUS),
467 const_iv (SDL_APPMOUSEFOCUS), 627 const_iv (SDL_APPMOUSEFOCUS),
468 const_iv (SDL_APPACTIVE), 628 const_iv (SDL_APPACTIVE),
469 629
630
631 const_iv (SDLK_UNKNOWN),
632 const_iv (SDLK_FIRST),
633 const_iv (SDLK_BACKSPACE),
634 const_iv (SDLK_TAB),
635 const_iv (SDLK_CLEAR),
636 const_iv (SDLK_RETURN),
637 const_iv (SDLK_PAUSE),
638 const_iv (SDLK_ESCAPE),
639 const_iv (SDLK_SPACE),
640 const_iv (SDLK_EXCLAIM),
641 const_iv (SDLK_QUOTEDBL),
642 const_iv (SDLK_HASH),
643 const_iv (SDLK_DOLLAR),
644 const_iv (SDLK_AMPERSAND),
645 const_iv (SDLK_QUOTE),
646 const_iv (SDLK_LEFTPAREN),
647 const_iv (SDLK_RIGHTPAREN),
648 const_iv (SDLK_ASTERISK),
649 const_iv (SDLK_PLUS),
650 const_iv (SDLK_COMMA),
651 const_iv (SDLK_MINUS),
652 const_iv (SDLK_PERIOD),
653 const_iv (SDLK_SLASH),
654 const_iv (SDLK_0),
655 const_iv (SDLK_1),
656 const_iv (SDLK_2),
657 const_iv (SDLK_3),
658 const_iv (SDLK_4),
659 const_iv (SDLK_5),
660 const_iv (SDLK_6),
661 const_iv (SDLK_7),
662 const_iv (SDLK_8),
663 const_iv (SDLK_9),
664 const_iv (SDLK_COLON),
665 const_iv (SDLK_SEMICOLON),
666 const_iv (SDLK_LESS),
667 const_iv (SDLK_EQUALS),
668 const_iv (SDLK_GREATER),
669 const_iv (SDLK_QUESTION),
670 const_iv (SDLK_AT),
671
672 const_iv (SDLK_LEFTBRACKET),
673 const_iv (SDLK_BACKSLASH),
674 const_iv (SDLK_RIGHTBRACKET),
675 const_iv (SDLK_CARET),
676 const_iv (SDLK_UNDERSCORE),
677 const_iv (SDLK_BACKQUOTE),
678 const_iv (SDLK_DELETE),
679
680 const_iv (SDLK_FIRST),
681 const_iv (SDLK_LAST),
470 const_iv (SDLK_KP0), 682 const_iv (SDLK_KP0),
471 const_iv (SDLK_KP1), 683 const_iv (SDLK_KP1),
472 const_iv (SDLK_KP2), 684 const_iv (SDLK_KP2),
473 const_iv (SDLK_KP3), 685 const_iv (SDLK_KP3),
474 const_iv (SDLK_KP4), 686 const_iv (SDLK_KP4),
546 const_iv (KMOD_LMETA), 758 const_iv (KMOD_LMETA),
547 const_iv (KMOD_RMETA), 759 const_iv (KMOD_RMETA),
548 const_iv (KMOD_NUM), 760 const_iv (KMOD_NUM),
549 const_iv (KMOD_CAPS), 761 const_iv (KMOD_CAPS),
550 const_iv (KMOD_MODE), 762 const_iv (KMOD_MODE),
763
764 const_iv (KMOD_LRAM),
765
766 const_iv (MIX_DEFAULT_FORMAT),
767
768 const_iv (SDL_INIT_TIMER),
769 const_iv (SDL_INIT_AUDIO),
770 const_iv (SDL_INIT_VIDEO),
771 const_iv (SDL_INIT_CDROM),
772 const_iv (SDL_INIT_JOYSTICK),
773 const_iv (SDL_INIT_EVERYTHING),
774 const_iv (SDL_INIT_NOPARACHUTE),
775 const_iv (SDL_INIT_EVENTTHREAD),
776
777 const_iv (SDL_GL_RED_SIZE),
778 const_iv (SDL_GL_GREEN_SIZE),
779 const_iv (SDL_GL_BLUE_SIZE),
780 const_iv (SDL_GL_ALPHA_SIZE),
781 const_iv (SDL_GL_DOUBLEBUFFER),
782 const_iv (SDL_GL_BUFFER_SIZE),
783 const_iv (SDL_GL_DEPTH_SIZE),
784 const_iv (SDL_GL_STENCIL_SIZE),
785 const_iv (SDL_GL_ACCUM_RED_SIZE),
786 const_iv (SDL_GL_ACCUM_GREEN_SIZE),
787 const_iv (SDL_GL_ACCUM_BLUE_SIZE),
788 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
789 const_iv (SDL_GL_STEREO),
790 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
791 const_iv (SDL_GL_MULTISAMPLESAMPLES),
792 const_iv (SDL_GL_ACCELERATED_VISUAL),
793 const_iv (SDL_GL_SWAP_CONTROL),
794
795 const_iv (FOW_DARKNESS)
551# undef const_iv 796# undef const_iv
552 }; 797 };
553 798
554 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 799 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
555 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 800 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
573 818
574NV floor (NV x) 819NV floor (NV x)
575 820
576NV ceil (NV x) 821NV ceil (NV x)
577 822
823IV minpot (UV n)
824
825IV popcount (UV n)
826
827NV distance (NV dx, NV dy)
828 CODE:
829 RETVAL = pow (dx * dx + dy * dy, 0.5);
830 OUTPUT:
831 RETVAL
832
578void 833void
579pango_init () 834pango_init ()
580 CODE: 835 CODE:
581{ 836{
582 opengl_fontmap = pango_opengl_font_map_new (); 837 opengl_fontmap = pango_opengl_font_map_new ();
583 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 838 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
584 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 839 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
840 /*pango_context_set_font_description (opengl_context, default_font);*/
841#if PANGO_VERSION_CHECK (1, 15, 2)
842 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
843 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
844#endif
585} 845}
586 846
587int 847char *SDL_GetError ()
588SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
589 848
590void 849void SDL_braino ()
850
851int SDL_Init (U32 flags)
852
853int SDL_InitSubSystem (U32 flags)
854
855void SDL_QuitSubSystem (U32 flags)
856
591SDL_Quit () 857void SDL_Quit ()
592 858
859int SDL_GL_SetAttribute (int attr, int value)
860
861int SDL_GL_GetAttribute (int attr)
862 CODE:
863 if (SDL_GL_GetAttribute (attr, &RETVAL))
864 XSRETURN_UNDEF;
865 OUTPUT:
866 RETVAL
867
593void 868void
594SDL_ListModes () 869SDL_ListModes (int rgb, int alpha)
595 PPCODE: 870 PPCODE:
596{ 871{
597 SDL_Rect **m; 872 SDL_Rect **m;
598 873
599 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 874 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
600 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 875 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
601 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 876 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
602 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 877 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
603 878
604 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 879 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
605 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 880 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
606 881
607 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 882 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
608 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 883 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
609 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 884 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
610 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 885 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
611 886
612 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 887 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
613#if SDL_VERSION_ATLEAST(1,2,10)
614 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
615 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 888 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
616#endif
617
618 SDL_EnableUNICODE (1);
619 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
620 889
621 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 890 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
622 891
623 if (m && m != (SDL_Rect **)-1) 892 if (m && m != (SDL_Rect **)-1)
624 while (*m) 893 while (*m)
625 { 894 {
895 if ((*m)->w >= 400 && (*m)->h >= 300)
896 {
626 AV *av = newAV (); 897 AV *av = newAV ();
627 av_push (av, newSViv ((*m)->w)); 898 av_push (av, newSViv ((*m)->w));
628 av_push (av, newSViv ((*m)->h)); 899 av_push (av, newSViv ((*m)->h));
900 av_push (av, newSViv (rgb));
901 av_push (av, newSViv (alpha));
629 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 902 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
903 }
630 904
631 ++m; 905 ++m;
632 } 906 }
633} 907}
634 908
635char *
636SDL_GetError ()
637
638int 909int
639SDL_SetVideoMode (int w, int h, int fullscreen) 910SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
640 CODE: 911 CODE:
912{
913 SDL_EnableUNICODE (1);
914 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
915
916 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
917 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
918 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
919 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
920
641 RETVAL = !!SDL_SetVideoMode ( 921 RETVAL = !!SDL_SetVideoMode (
642 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 922 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
643 ); 923 );
924
644 if (RETVAL) 925 if (RETVAL)
645 { 926 {
646 av_clear (texture_av); 927 av_clear (texture_av);
647 928
648 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 929 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
649# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 930#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
650# include "glfunc.h" 931#include "glfunc.h"
651# undef GL_FUNC 932#undef GL_FUNC
652
653 } 933 }
934}
654 OUTPUT: 935 OUTPUT:
655 RETVAL 936 RETVAL
656 937
657void 938void
658SDL_GL_SwapBuffers () 939SDL_GL_SwapBuffers ()
659 940
660char * 941char *
661SDL_GetKeyName (int sym) 942SDL_GetKeyName (int sym)
662 943
944int
945SDL_GetAppState ()
946
947int
948SDL_GetModState ()
949
663void 950void
664SDL_PollEvent () 951poll_events ()
665 PPCODE: 952 PPCODE:
666{ 953{
667 SDL_Event ev; 954 SDL_Event ev;
668 955
669 while (SDL_PollEvent (&ev)) 956 SDL_PumpEvents ();
957 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
670 { 958 {
671 HV *hv = newHV (); 959 HV *hv = newHV ();
672 hv_store (hv, "type", 4, newSViv (ev.type), 0); 960 hv_store (hv, "type", 4, newSViv (ev.type), 0);
673 961
674 switch (ev.type) 962 switch (ev.type)
675 { 963 {
676 case SDL_KEYDOWN: 964 case SDL_KEYDOWN:
677 case SDL_KEYUP: 965 case SDL_KEYUP:
678 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 966 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
679 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 967 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
680 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 968 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
681 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */ 969 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
682 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 970 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
683 break; 971 break;
684 972
685 case SDL_ACTIVEEVENT: 973 case SDL_ACTIVEEVENT:
686 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 974 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
687 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 975 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
688 break; 976 break;
689 977
690 case SDL_MOUSEMOTION: 978 case SDL_MOUSEMOTION:
979 {
980 int state = ev.motion.state;
981 int x = ev.motion.x;
982 int y = ev.motion.y;
983 int xrel = ev.motion.xrel;
984 int yrel = ev.motion.yrel;
985
986 /* do simplistic event compression */
987 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
988 && state == ev.motion.state)
989 {
990 xrel += ev.motion.xrel;
991 yrel += ev.motion.yrel;
992 x = ev.motion.x;
993 y = ev.motion.y;
994 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
995 }
996
691 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 997 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
692
693 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 998 hv_store (hv, "state", 5, newSViv (state), 0);
694 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 999 hv_store (hv, "x", 1, newSViv (x), 0);
695 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 1000 hv_store (hv, "y", 1, newSViv (y), 0);
696 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 1001 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
697 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 1002 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
1003 }
698 break; 1004 break;
699 1005
700 case SDL_MOUSEBUTTONDOWN: 1006 case SDL_MOUSEBUTTONDOWN:
701 case SDL_MOUSEBUTTONUP: 1007 case SDL_MOUSEBUTTONUP:
702 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1008 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
703 1009
704 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 1010 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
705 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 1011 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
706 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 1012 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
707 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 1013 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
712 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 1018 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
713 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 1019 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
714 break; 1020 break;
715 } 1021 }
716 1022
717 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1)))); 1023 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
718 } 1024 }
719} 1025}
720 1026
721int 1027int
722Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048) 1028Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
723 POSTCALL: 1029 POSTCALL:
724 Mix_HookMusicFinished (music_finished); 1030 Mix_HookMusicFinished (music_finished);
725 Mix_ChannelFinished (channel_finished); 1031 Mix_ChannelFinished (channel_finished);
726 1032
727void 1033void
1034Mix_QuerySpec ()
1035 PPCODE:
1036{
1037 int freq, channels;
1038 Uint16 format;
1039
1040 if (Mix_QuerySpec (&freq, &format, &channels))
1041 {
1042 EXTEND (SP, 3);
1043 PUSHs (sv_2mortal (newSViv (freq)));
1044 PUSHs (sv_2mortal (newSViv (format)));
1045 PUSHs (sv_2mortal (newSViv (channels)));
1046 }
1047}
1048
1049void
728Mix_CloseAudio () 1050Mix_CloseAudio ()
729 1051
730int 1052int
731Mix_AllocateChannels (int numchans = -1) 1053Mix_AllocateChannels (int numchans = -1)
1054
1055const char *
1056Mix_GetError ()
732 1057
733void 1058void
734lowdelay (int fd, int val = 1) 1059lowdelay (int fd, int val = 1)
735 CODE: 1060 CODE:
736 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val)); 1061 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
762 } 1087 }
763 } 1088 }
764#endif 1089#endif
765} 1090}
766 1091
767void 1092int
768add_font (char *file) 1093add_font (char *file)
769 CODE: 1094 CODE:
770 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1095 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1096 OUTPUT:
1097 RETVAL
771 1098
772void 1099void
773load_image_inline (SV *image_) 1100load_image_inline (SV *image_)
774 ALIAS: 1101 ALIAS:
775 load_image_file = 1 1102 load_image_file = 1
778 STRLEN image_len; 1105 STRLEN image_len;
779 char *image = (char *)SvPVbyte (image_, image_len); 1106 char *image = (char *)SvPVbyte (image_, image_len);
780 SDL_Surface *surface, *surface2; 1107 SDL_Surface *surface, *surface2;
781 SDL_PixelFormat fmt; 1108 SDL_PixelFormat fmt;
782 SDL_RWops *rw = ix 1109 SDL_RWops *rw = ix
783 ? SDL_RWFromFile (image, "r") 1110 ? SDL_RWFromFile (image, "rb")
784 : SDL_RWFromConstMem (image, image_len); 1111 : SDL_RWFromConstMem (image, image_len);
785 1112
786 if (!rw) 1113 if (!rw)
787 croak ("load_image: %s", SDL_GetError ()); 1114 croak ("load_image: %s", SDL_GetError ());
788 1115
861void 1188void
862error (char *message) 1189error (char *message)
863 CODE: 1190 CODE:
864 fprintf (stderr, "ERROR: %s\n", message); 1191 fprintf (stderr, "ERROR: %s\n", message);
865#ifdef _WIN32 1192#ifdef _WIN32
866 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR); 1193 MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
867#endif 1194#endif
868 1195
869void 1196void
870fatal (char *message) 1197fatal (char *message)
871 CODE: 1198 CODE:
872 fprintf (stderr, "FATAL: %s\n", message); 1199 fprintf (stderr, "FATAL: %s\n", message);
873#ifdef _WIN32 1200#ifdef _WIN32
874 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 1201 MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
875#endif 1202#endif
876 _exit (1); 1203 _exit (1);
877 1204
878void 1205void
879_exit (int retval = 0) 1206_exit (int retval = 0)
882 ExitThread (retval); // unclean, please beam me up 1209 ExitThread (retval); // unclean, please beam me up
883#else 1210#else
884 _exit (retval); 1211 _exit (retval);
885#endif 1212#endif
886 1213
887MODULE = CFPlus PACKAGE = CFPlus::Font 1214void
1215debug ()
1216 CODE:
1217{
1218#if DEBUG
1219 VALGRIND_DO_LEAK_CHECK;
1220#endif
1221}
888 1222
889CFPlus::Font 1223int
1224SvREFCNT (SV *sv)
1225 CODE:
1226 RETVAL = SvREFCNT (sv);
1227 OUTPUT:
1228 RETVAL
1229
1230MODULE = Deliantra::Client PACKAGE = DC::Font
1231
1232PROTOTYPES: DISABLE
1233
1234DC::Font
890new_from_file (SV *class, char *path, int id = 0) 1235new_from_file (SV *class, char *path, int id = 0)
891 CODE: 1236 CODE:
892{ 1237{
893 int count; 1238 int count;
894 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1239 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
897} 1242}
898 OUTPUT: 1243 OUTPUT:
899 RETVAL 1244 RETVAL
900 1245
901void 1246void
902DESTROY (CFPlus::Font self) 1247DESTROY (DC::Font self)
903 CODE: 1248 CODE:
904 pango_font_description_free (self); 1249 pango_font_description_free (self);
905 1250
906void 1251void
907make_default (CFPlus::Font self) 1252make_default (DC::Font self)
1253 PROTOTYPE: $
908 CODE: 1254 CODE:
909 default_font = self; 1255 default_font = self;
910 1256
911MODULE = CFPlus PACKAGE = CFPlus::Layout 1257MODULE = Deliantra::Client PACKAGE = DC::Layout
912 1258
1259PROTOTYPES: DISABLE
1260
913void 1261void
914reset_glyph_cache () 1262glyph_cache_backup ()
1263 PROTOTYPE:
915 CODE: 1264 CODE:
1265 tc_backup ();
1266
1267void
1268glyph_cache_restore ()
1269 PROTOTYPE:
1270 CODE:
916 tc_clear (); 1271 tc_restore ();
917 1272
918CFPlus::Layout 1273DC::Layout
919new (SV *class) 1274new (SV *class)
920 CODE: 1275 CODE:
921 New (0, RETVAL, 1, struct cf_layout); 1276 New (0, RETVAL, 1, struct cf_layout);
922 1277
923 RETVAL->pl = pango_layout_new (opengl_context); 1278 RETVAL->pl = pango_layout_new (opengl_context);
925 RETVAL->g = 1.; 1280 RETVAL->g = 1.;
926 RETVAL->b = 1.; 1281 RETVAL->b = 1.;
927 RETVAL->a = 1.; 1282 RETVAL->a = 1.;
928 RETVAL->base_height = MIN_FONT_HEIGHT; 1283 RETVAL->base_height = MIN_FONT_HEIGHT;
929 RETVAL->font = 0; 1284 RETVAL->font = 0;
1285 RETVAL->rc = rc_alloc ();
930 1286
931 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1287 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
932 layout_update_font (RETVAL); 1288 layout_update_font (RETVAL);
933 OUTPUT: 1289 OUTPUT:
934 RETVAL 1290 RETVAL
935 1291
936void 1292void
937DESTROY (CFPlus::Layout self) 1293DESTROY (DC::Layout self)
938 CODE: 1294 CODE:
939 g_object_unref (self->pl); 1295 g_object_unref (self->pl);
1296 rc_free (self->rc);
940 Safefree (self); 1297 Safefree (self);
941 1298
942void 1299void
943set_text (CFPlus::Layout self, SV *text_) 1300set_text (DC::Layout self, SV *text_)
944 CODE: 1301 CODE:
945{ 1302{
946 STRLEN textlen; 1303 STRLEN textlen;
947 char *text = SvPVutf8 (text_, textlen); 1304 char *text = SvPVutf8 (text_, textlen);
948 1305
949 pango_layout_set_text (self->pl, text, textlen); 1306 pango_layout_set_text (self->pl, text, textlen);
950} 1307}
951 1308
952void 1309void
953set_markup (CFPlus::Layout self, SV *text_) 1310set_markup (DC::Layout self, SV *text_)
954 CODE: 1311 CODE:
955{ 1312{
956 STRLEN textlen; 1313 STRLEN textlen;
957 char *text = SvPVutf8 (text_, textlen); 1314 char *text = SvPVutf8 (text_, textlen);
958 1315
959 pango_layout_set_markup (self->pl, text, textlen); 1316 pango_layout_set_markup (self->pl, text, textlen);
960} 1317}
961 1318
962void 1319void
963set_shapes (CFPlus::Layout self, ...) 1320set_shapes (DC::Layout self, ...)
964 CODE: 1321 CODE:
965{ 1322{
966 PangoAttrList *attrs = 0; 1323 PangoAttrList *attrs = 0;
967 const char *text = pango_layout_get_text (self->pl); 1324 const char *text = pango_layout_get_text (self->pl);
968 const char *pos = text; 1325 const char *pos = text;
1003 if (attrs) 1360 if (attrs)
1004 pango_layout_set_attributes (self->pl, attrs); 1361 pango_layout_set_attributes (self->pl, attrs);
1005} 1362}
1006 1363
1007void 1364void
1008get_shapes (CFPlus::Layout self) 1365get_shapes (DC::Layout self)
1009 PPCODE: 1366 PPCODE:
1010{ 1367{
1011 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1368 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1012 1369
1013 do 1370 do
1014 { 1371 {
1015 PangoLayoutRun *run = pango_layout_iter_get_run (iter); 1372 PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
1016 1373
1017 if (run && shape_attr_p (run)) 1374 if (run && shape_attr_p (run))
1018 { 1375 {
1019 PangoRectangle extents; 1376 PangoRectangle extents;
1020 pango_layout_iter_get_run_extents (iter, 0, &extents); 1377 pango_layout_iter_get_run_extents (iter, 0, &extents);
1028 1385
1029 pango_layout_iter_free (iter); 1386 pango_layout_iter_free (iter);
1030} 1387}
1031 1388
1032int 1389int
1033has_wrapped (CFPlus::Layout self) 1390has_wrapped (DC::Layout self)
1034 CODE: 1391 CODE:
1035{ 1392{
1036 int lines = 1; 1393 int lines = 1;
1037 const char *text = pango_layout_get_text (self->pl); 1394 const char *text = pango_layout_get_text (self->pl);
1038 1395
1043} 1400}
1044 OUTPUT: 1401 OUTPUT:
1045 RETVAL 1402 RETVAL
1046 1403
1047SV * 1404SV *
1048get_text (CFPlus::Layout self) 1405get_text (DC::Layout self)
1049 CODE: 1406 CODE:
1050 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1407 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1051 sv_utf8_decode (RETVAL); 1408 sv_utf8_decode (RETVAL);
1052 OUTPUT: 1409 OUTPUT:
1053 RETVAL 1410 RETVAL
1054 1411
1055void 1412void
1056set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.) 1413set_foreground (DC::Layout self, float r, float g, float b, float a = 1.)
1057 CODE: 1414 CODE:
1058 self->r = r; 1415 self->r = r;
1059 self->g = g; 1416 self->g = g;
1060 self->b = b; 1417 self->b = b;
1061 self->a = a; 1418 self->a = a;
1062 1419
1063void 1420void
1064set_font (CFPlus::Layout self, CFPlus::Font font = 0) 1421set_font (DC::Layout self, DC::Font font = 0)
1065 CODE: 1422 CODE:
1066 if (self->font != font) 1423 if (self->font != font)
1067 { 1424 {
1068 self->font = font; 1425 self->font = font;
1069 layout_update_font (self); 1426 layout_update_font (self);
1070 } 1427 }
1071 1428
1072void 1429void
1073set_height (CFPlus::Layout self, int base_height) 1430set_height (DC::Layout self, int base_height)
1074 CODE: 1431 CODE:
1075 if (self->base_height != base_height) 1432 if (self->base_height != base_height)
1076 { 1433 {
1077 self->base_height = base_height; 1434 self->base_height = base_height;
1078 layout_update_font (self); 1435 layout_update_font (self);
1079 } 1436 }
1080 1437
1081void 1438void
1082set_width (CFPlus::Layout self, int max_width = -1) 1439set_width (DC::Layout self, int max_width = -1)
1083 CODE: 1440 CODE:
1084 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1441 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
1085 1442
1086void 1443void
1087set_indent (CFPlus::Layout self, int indent) 1444set_indent (DC::Layout self, int indent)
1088 CODE: 1445 CODE:
1089 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1446 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1090 1447
1091void 1448void
1092set_spacing (CFPlus::Layout self, int spacing) 1449set_spacing (DC::Layout self, int spacing)
1093 CODE: 1450 CODE:
1094 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1451 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1095 1452
1096void 1453void
1097set_ellipsise (CFPlus::Layout self, int ellipsise) 1454set_ellipsise (DC::Layout self, int ellipsise)
1098 CODE: 1455 CODE:
1099 pango_layout_set_ellipsize (self->pl, 1456 pango_layout_set_ellipsize (self->pl,
1100 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1457 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1101 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1458 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1102 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1459 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1103 : PANGO_ELLIPSIZE_NONE 1460 : PANGO_ELLIPSIZE_NONE
1104 ); 1461 );
1105 1462
1106void 1463void
1107set_single_paragraph_mode (CFPlus::Layout self, int spm) 1464set_single_paragraph_mode (DC::Layout self, int spm)
1108 CODE: 1465 CODE:
1109 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1466 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1110 1467
1111void 1468void
1112size (CFPlus::Layout self) 1469size (DC::Layout self)
1113 PPCODE: 1470 PPCODE:
1114{ 1471{
1115 int w, h; 1472 int w, h;
1116 1473
1117 layout_get_pixel_size (self, &w, &h); 1474 layout_get_pixel_size (self, &w, &h);
1120 PUSHs (sv_2mortal (newSViv (w))); 1477 PUSHs (sv_2mortal (newSViv (w)));
1121 PUSHs (sv_2mortal (newSViv (h))); 1478 PUSHs (sv_2mortal (newSViv (h)));
1122} 1479}
1123 1480
1124int 1481int
1125descent (CFPlus::Layout self) 1482descent (DC::Layout self)
1126 CODE: 1483 CODE:
1127{ 1484{
1128 PangoRectangle rect; 1485 PangoRectangle rect;
1129 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1486 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1130 pango_layout_line_get_pixel_extents (line, 0, &rect); 1487 pango_layout_line_get_pixel_extents (line, 0, &rect);
1131 RETVAL = PANGO_DESCENT (rect); 1488 RETVAL = PANGO_DESCENT (rect);
1132} 1489}
1133 OUTPUT: 1490 OUTPUT:
1134 RETVAL 1491 RETVAL
1135 1492
1136int 1493int
1137xy_to_index (CFPlus::Layout self, int x, int y) 1494xy_to_index (DC::Layout self, int x, int y)
1138 CODE: 1495 CODE:
1139{ 1496{
1140 int index, trailing; 1497 int index, trailing;
1141 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1498 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1142 RETVAL = index + trailing; 1499 RETVAL = index + trailing;
1143} 1500}
1144 OUTPUT: 1501 OUTPUT:
1145 RETVAL 1502 RETVAL
1146 1503
1147void 1504void
1148cursor_pos (CFPlus::Layout self, int index) 1505cursor_pos (DC::Layout self, int index)
1149 PPCODE: 1506 PPCODE:
1150{ 1507{
1151 PangoRectangle strong_pos; 1508 PangoRectangle pos;
1152 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1509 pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1153 1510
1154 EXTEND (SP, 3); 1511 EXTEND (SP, 3);
1155 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1512 PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1156 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1513 PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1157 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1514 PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1158} 1515}
1159 1516
1160void 1517void
1161index_to_line_x (CFPlus::Layout self, int index, int trailing = 0) 1518index_to_line_x (DC::Layout self, int index, int trailing = 0)
1162 PPCODE: 1519 PPCODE:
1163{ 1520{
1164 int line, x; 1521 int line, x;
1165 1522
1166 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x); 1523 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1524#if !PANGO_VERSION_CHECK (1, 17, 3)
1167 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1525 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1168 1526 --line;
1527#endif
1169 EXTEND (SP, 2); 1528 EXTEND (SP, 2);
1170 PUSHs (sv_2mortal (newSViv (line - 1))); 1529 PUSHs (sv_2mortal (newSViv (line)));
1171 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE))); 1530 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1172} 1531}
1173 1532
1174void 1533void
1175line_x_to_index (CFPlus::Layout self, int line, int x) 1534line_x_to_index (DC::Layout self, int line, int x)
1176 PPCODE: 1535 PPCODE:
1177{ 1536{
1178 PangoLayoutLine *lp; 1537 PangoLayoutLine *lp;
1179 int index, trailing; 1538 int index, trailing;
1180 1539
1181 if (line < 0) 1540 if (line < 0)
1182 XSRETURN_EMPTY; 1541 XSRETURN_EMPTY;
1183 1542
1184 if (!(lp = pango_layout_get_line (self->pl, line))) 1543 if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1185 XSRETURN_EMPTY; /* do better */ 1544 XSRETURN_EMPTY; /* do better */
1186 1545
1187 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing); 1546 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1188 1547
1189 EXTEND (SP, 2); 1548 EXTEND (SP, 2);
1195 PUSHs (sv_2mortal (newSViv (trailing))); 1554 PUSHs (sv_2mortal (newSViv (trailing)));
1196 } 1555 }
1197} 1556}
1198 1557
1199void 1558void
1200render (CFPlus::Layout self, float x, float y, int flags = 0) 1559render (DC::Layout self, float x, float y, int flags = 0)
1201 PPCODE: 1560 CODE:
1561 rc_clear (self->rc);
1202 pango_opengl_render_layout_subpixel ( 1562 pango_opengl_render_layout_subpixel (
1203 self->pl, 1563 self->pl,
1564 self->rc,
1204 x * PANGO_SCALE, y * PANGO_SCALE, 1565 x * PANGO_SCALE, y * PANGO_SCALE,
1205 self->r, self->g, self->b, self->a, 1566 self->r, self->g, self->b, self->a,
1206 flags 1567 flags
1207 ); 1568 );
1569 // we assume that context_change actually clears/frees stuff
1570 // and does not do any recomputation...
1571 pango_layout_context_changed (self->pl);
1208 1572
1209MODULE = CFPlus PACKAGE = CFPlus::Texture
1210
1211void 1573void
1212pad2pot (SV *data_, SV *w_, SV *h_) 1574draw (DC::Layout self)
1213 CODE: 1575 CODE:
1214{ 1576{
1215 int ow = SvIV (w_); 1577 glEnable (GL_TEXTURE_2D);
1216 int oh = SvIV (h_); 1578 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1579 glEnable (GL_BLEND);
1580 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1581 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1582 glEnable (GL_ALPHA_TEST);
1583 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1217 1584
1218 if (ow && oh) 1585 rc_draw (self->rc);
1586
1587 glDisable (GL_ALPHA_TEST);
1588 glDisable (GL_BLEND);
1589 glDisable (GL_TEXTURE_2D);
1590}
1591
1592MODULE = Deliantra::Client PACKAGE = DC::Texture
1593
1594PROTOTYPES: ENABLE
1595
1596void
1597pad (SV *data_, int ow, int oh, int nw, int nh)
1598 CODE:
1599{
1600 if ((nw != ow || nh != oh) && SvOK (data_))
1219 { 1601 {
1220 int nw = minpot (ow);
1221 int nh = minpot (oh);
1222
1223 if (nw != ow || nh != oh)
1224 {
1225 if (SvOK (data_))
1226 {
1227 STRLEN datalen; 1602 STRLEN datalen;
1228 char *data = SvPVbyte (data_, datalen); 1603 char *data = SvPVbyte (data_, datalen);
1229 int bpp = datalen / (ow * oh); 1604 int bpp = datalen / (ow * oh);
1230 SV *result_ = sv_2mortal (newSV (nw * nh * bpp)); 1605 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1231 1606
1232 SvPOK_only (result_); 1607 SvPOK_only (result_);
1233 SvCUR_set (result_, nw * nh * bpp); 1608 SvCUR_set (result_, nw * nh * bpp);
1234 1609
1235 memset (SvPVX (result_), 0, nw * nh * bpp); 1610 memset (SvPVX (result_), 0, nw * nh * bpp);
1236 while (oh--) 1611 while (oh--)
1237 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp); 1612 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1238 1613
1239 sv_setsv (data_, result_); 1614 sv_setsv (data_, result_);
1240 }
1241
1242 sv_setiv (w_, nw);
1243 sv_setiv (h_, nh);
1244 }
1245 } 1615 }
1246} 1616}
1247 1617
1248void 1618void
1249draw_quad (SV *self, float x, float y, float w = 0., float h = 0.) 1619draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
1255{ 1625{
1256 HV *hv = (HV *)SvRV (self); 1626 HV *hv = (HV *)SvRV (self);
1257 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1627 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
1258 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1628 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
1259 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1629 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
1630
1631 if (name <= 0)
1632 XSRETURN_EMPTY;
1260 1633
1261 if (items < 5) 1634 if (items < 5)
1262 { 1635 {
1263 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1636 w = SvNV (*hv_fetch (hv, "w", 1, 1));
1264 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1637 h = SvNV (*hv_fetch (hv, "h", 1, 1));
1292 glDisable (GL_ALPHA_TEST); 1665 glDisable (GL_ALPHA_TEST);
1293 glDisable (GL_BLEND); 1666 glDisable (GL_BLEND);
1294 } 1667 }
1295} 1668}
1296 1669
1297MODULE = CFPlus PACKAGE = CFPlus::Map 1670void
1671draw_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)
1672 PROTOTYPE: @
1673 CODE:
1674{
1675 glEnable (GL_TEXTURE_2D);
1676 glEnable (GL_BLEND);
1677 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1678 glBindTexture (GL_TEXTURE_2D, name1);
1298 1679
1299CFPlus::Map 1680 glColor3f (intensity, intensity, intensity);
1681 glPushMatrix ();
1682 glScalef (1./3, 1./3, 1.);
1683
1684 if (blend > 0.f)
1685 {
1686 float dx3 = dx * -3.f / w;
1687 float dy3 = dy * -3.f / h;
1688 GLfloat env_color[4] = { 0., 0., 0., blend };
1689
1690 /* interpolate the two shadow textures */
1691 /* stage 0 == rgb(glcolor) + alpha(t0) */
1692 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1693
1694 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1695 gl.ActiveTexture (GL_TEXTURE1);
1696 glEnable (GL_TEXTURE_2D);
1697 glBindTexture (GL_TEXTURE_2D, name2);
1698 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1699
1700 /* rgb == rgb(glcolor) */
1701 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1702 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
1703 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1704
1705 /* alpha = interpolate t0, t1 by env_alpha */
1706 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1707
1708 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1709 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1710 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1711
1712 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1713 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1714
1715 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1716 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1717
1718 glBegin (GL_QUADS);
1719 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1720 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1721 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1722 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1723 glEnd ();
1724
1725 glDisable (GL_TEXTURE_2D);
1726 gl.ActiveTexture (GL_TEXTURE0);
1727 }
1728 else
1729 {
1730 /* simple blending of one texture, also opengl <1.3 path */
1731 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1732
1733 glBegin (GL_QUADS);
1734 glTexCoord2f (0, 0); glVertex2f (0, 0);
1735 glTexCoord2f (0, t); glVertex2f (0, h);
1736 glTexCoord2f (s, t); glVertex2f (w, h);
1737 glTexCoord2f (s, 0); glVertex2f (w, 0);
1738 glEnd ();
1739 }
1740
1741 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1742 {
1743 int x, y;
1744 int dx3 = dx * 3;
1745 int dy3 = dy * 3;
1746
1747 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1748 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1749 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1750 glTranslatef (-1., -1., 0);
1751 glBegin (GL_QUADS);
1752
1753 for (y = 1; y < h; y += 3)
1754 {
1755 int y1 = y - dy3;
1756 int y1valid = y1 >= 0 && y1 < h;
1757
1758 for (x = 1; x < w; x += 3)
1759 {
1760 int x1 = x - dx3;
1761 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1762 uint8_t h2;
1763
1764 if (y1valid && x1 >= 0 && x1 < w)
1765 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1766 else
1767 h2 = 1; /* out of range == invisible */
1768
1769 if (h1 || h2)
1770 {
1771 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1772 glColor4f (1., 1., 1., alpha);
1773
1774 glTexCoord2f (0, 0.); glVertex2i (x , y );
1775 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1776 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1777 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1778 }
1779 }
1780 }
1781 }
1782
1783 glEnd ();
1784
1785 glPopMatrix ();
1786
1787 glDisable (GL_TEXTURE_2D);
1788 glDisable (GL_BLEND);
1789}
1790
1791IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1792 CODE:
1793{
1794 GLint width;
1795 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1796 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1797 RETVAL = width > 0;
1798}
1799 OUTPUT:
1800 RETVAL
1801
1802MODULE = Deliantra::Client PACKAGE = DC::Map
1803
1804PROTOTYPES: DISABLE
1805
1806DC::Map
1300new (SV *class) 1807new (SV *class)
1301 CODE: 1808 CODE:
1302 New (0, RETVAL, 1, struct map); 1809 New (0, RETVAL, 1, struct map);
1303 RETVAL->x = 0; 1810 RETVAL->x = 0;
1304 RETVAL->y = 0; 1811 RETVAL->y = 0;
1312 RETVAL->row = 0; 1819 RETVAL->row = 0;
1313 OUTPUT: 1820 OUTPUT:
1314 RETVAL 1821 RETVAL
1315 1822
1316void 1823void
1317DESTROY (CFPlus::Map self) 1824DESTROY (DC::Map self)
1318 CODE: 1825 CODE:
1319{ 1826{
1320 map_clear (self); 1827 map_clear (self);
1321 Safefree (self->face2tile); 1828 Safefree (self->face2tile);
1322 Safefree (self->tex); 1829 Safefree (self->tex);
1323 Safefree (self); 1830 Safefree (self);
1324} 1831}
1325 1832
1326void 1833void
1327resize (CFPlus::Map self, int map_width, int map_height) 1834resize (DC::Map self, int map_width, int map_height)
1328 CODE: 1835 CODE:
1329 self->w = map_width; 1836 self->w = map_width;
1330 self->h = map_height; 1837 self->h = map_height;
1331 1838
1332void 1839void
1333clear (CFPlus::Map self) 1840clear (DC::Map self)
1334 CODE: 1841 CODE:
1335 map_clear (self); 1842 map_clear (self);
1336 1843
1337void 1844void
1338set_tileid (CFPlus::Map self, int face, int tile) 1845set_tileid (DC::Map self, int face, int tile)
1339 CODE: 1846 CODE:
1340{ 1847{
1341 need_facenum (self, face); self->face2tile [face] = tile; 1848 need_facenum (self, face); self->face2tile [face] = tile;
1342 need_texid (self, tile); 1849 need_texid (self, tile);
1343} 1850}
1344 1851
1345void 1852void
1346set_smooth (CFPlus::Map self, int face, int smooth, int level) 1853set_smooth (DC::Map self, int face, int smooth, int level)
1347 CODE: 1854 CODE:
1348{ 1855{
1349 tileid texid; 1856 tileid texid;
1350 maptex *tex; 1857 maptex *tex;
1351 1858
1364 tex->smoothtile = self->face2tile [smooth]; 1871 tex->smoothtile = self->face2tile [smooth];
1365 tex->smoothlevel = level; 1872 tex->smoothlevel = level;
1366} 1873}
1367 1874
1368void 1875void
1369set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1876set_texture (DC::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1370 CODE: 1877 CODE:
1371{ 1878{
1372 need_texid (self, texid); 1879 need_texid (self, texid);
1373 1880
1374 { 1881 {
1393 // use uglier nearest interpolation because linear suffers 1900 // use uglier nearest interpolation because linear suffers
1394 // from transparent color bleeding and ugly wrapping effects. 1901 // from transparent color bleeding and ugly wrapping effects.
1395 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1902 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1396} 1903}
1397 1904
1905void
1906expire_textures (DC::Map self, int texid, int count)
1907 PPCODE:
1908 for (; texid < self->texs && count; ++texid, --count)
1909 {
1910 maptex *tex = self->tex + texid;
1911
1912 if (tex->name)
1913 {
1914 if (tex->unused)
1915 {
1916 tex->name = 0;
1917 tex->unused = 0;
1918 XPUSHs (sv_2mortal (newSViv (texid)));
1919 }
1920 else
1921 tex->unused = 1;
1922 }
1923 }
1924
1398int 1925int
1399ox (CFPlus::Map self) 1926ox (DC::Map self)
1400 ALIAS: 1927 ALIAS:
1401 oy = 1 1928 oy = 1
1402 x = 2 1929 x = 2
1403 y = 3 1930 y = 3
1404 w = 4 1931 w = 4
1415 } 1942 }
1416 OUTPUT: 1943 OUTPUT:
1417 RETVAL 1944 RETVAL
1418 1945
1419void 1946void
1420scroll (CFPlus::Map self, int dx, int dy) 1947scroll (DC::Map self, int dx, int dy)
1421 CODE: 1948 CODE:
1422{ 1949{
1423 if (dx > 0) 1950 if (dx > 0)
1424 map_blank (self, self->x, self->y, dx, self->h); 1951 map_blank (self, self->x, self->y, dx, self->h);
1425 else if (dx < 0) 1952 else if (dx < 0)
1440 self->rows += MAP_EXTEND_Y; 1967 self->rows += MAP_EXTEND_Y;
1441 self->y += MAP_EXTEND_Y; 1968 self->y += MAP_EXTEND_Y;
1442 } 1969 }
1443} 1970}
1444 1971
1445void 1972SV *
1446map1a_update (CFPlus::Map self, SV *data_, int extmap) 1973map1a_update (DC::Map self, SV *data_, int extmap)
1447 CODE: 1974 CODE:
1448{ 1975{
1449 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1976 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1450 uint8_t *data_end = (uint8_t *)SvEND (data_); 1977 uint8_t *data_end = (uint8_t *)SvEND (data_);
1451 mapcell *cell; 1978 mapcell *cell;
1452 int x, y, flags; 1979 int x, y, z, flags;
1980 AV *missing = newAV ();
1981 RETVAL = newRV_noinc ((SV *)missing);
1453 1982
1454 while (data < data_end - 1) 1983 while (data < data_end - 1)
1455 { 1984 {
1456 flags = (data [0] << 8) + data [1]; data += 2; 1985 flags = (data [0] << 8) + data [1]; data += 2;
1457 1986
1477 uint8_t ext, cmd; 2006 uint8_t ext, cmd;
1478 2007
1479 do 2008 do
1480 { 2009 {
1481 ext = *data++; 2010 ext = *data++;
1482 cmd = ext & 0x3f; 2011 cmd = ext & 0x7f;
1483 2012
1484 if (cmd < 4) 2013 if (cmd < 4)
1485 cell->darkness = 255 - ext * 64 + 1; 2014 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
1486 else if (cmd == 5) // health 2015 else if (cmd == 5) // health
1487 { 2016 {
1488 cell->stat_width = 1; 2017 cell->stat_width = 1;
1489 cell->stat_hp = *data++; 2018 cell->stat_hp = *data++;
1490 } 2019 }
1491 else if (cmd == 6) // monster width 2020 else if (cmd == 6) // monster width
1492 cell->stat_width = *data++ + 1; 2021 cell->stat_width = *data++ + 1;
1493 else if (cmd == 0x47) 2022 else if (cmd == 0x47)
1494 { 2023 {
1495 if (*data == 4) 2024 if (*data == 1) cell->player = data [1];
1496 ; // decode player count 2025 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2026 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2027 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
1497 2028
1498 data += *data + 1; 2029 data += *data + 1;
1499 } 2030 }
1500 else if (cmd == 8) // cell flags 2031 else if (cmd == 8) // cell flags
1501 cell->flags = *data++; 2032 cell->flags = *data++;
1508 } 2039 }
1509 else 2040 else
1510 cell->darkness = *data++ + 1; 2041 cell->darkness = *data++ + 1;
1511 } 2042 }
1512 2043
2044 for (z = 0; z <= 2; ++z)
1513 if (flags & 4) 2045 if (flags & (4 >> z))
1514 { 2046 {
1515 faceid face = (data [0] << 8) + data [1]; data += 2; 2047 faceid face = (data [0] << 8) + data [1]; data += 2;
1516 need_facenum (self, face); 2048 need_facenum (self, face);
1517 cell->tile [0] = self->face2tile [face]; 2049 cell->tile [z] = self->face2tile [face];
2050
2051 if (cell->tile [z])
2052 {
2053 maptex *tex = self->tex + cell->tile [z];
2054 tex->unused = 0;
2055 if (!tex->name)
2056 av_push (missing, newSViv (cell->tile [z]));
2057
2058 if (tex->smoothtile)
2059 {
2060 maptex *smooth = self->tex + tex->smoothtile;
2061 smooth->unused = 0;
2062 if (!smooth->name)
2063 av_push (missing, newSViv (tex->smoothtile));
2064 }
2065 }
1518 } 2066 }
1519
1520 if (flags & 2)
1521 {
1522 faceid face = (data [0] << 8) + data [1]; data += 2;
1523 need_facenum (self, face);
1524 cell->tile [1] = self->face2tile [face];
1525 }
1526
1527 if (flags & 1)
1528 {
1529 faceid face = (data [0] << 8) + data [1]; data += 2;
1530 need_facenum (self, face);
1531 cell->tile [2] = self->face2tile [face];
1532 }
1533 } 2067 }
1534 else 2068 else
1535 cell->darkness = 0; 2069 CELL_CLEAR (cell);
1536 } 2070 }
1537} 2071}
2072 OUTPUT:
2073 RETVAL
1538 2074
1539SV * 2075SV *
1540mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 2076mapmap (DC::Map self, int x0, int y0, int w, int h)
1541 CODE: 2077 CODE:
1542{ 2078{
1543 int x1, x; 2079 int x1, x;
1544 int y1, y; 2080 int y1, y;
1545 int z; 2081 int z;
1590} 2126}
1591 OUTPUT: 2127 OUTPUT:
1592 RETVAL 2128 RETVAL
1593 2129
1594void 2130void
1595draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T) 2131draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1596 CODE: 2132 CODE:
1597{ 2133{
2134 int x, y, z;
2135
1598 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ()); 2136 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1599 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level 2137 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1600 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k) 2138 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1601 smooth_key skey; 2139 smooth_key skey;
1602 int x, y, z; 2140 int pl_x, pl_y;
1603 int last_name; 2141 maptex pl_tex;
2142 rc_t *rc = rc_alloc ();
2143 rc_t *rc_ov = rc_alloc ();
2144 rc_key_t key;
2145 rc_array_t *arr;
1604 2146
2147 pl_tex.name = 0;
2148
1605 // thats current max. sorry. 2149 // that's current max. sorry.
1606 if (sw > 255) sw = 255; 2150 if (sw > 255) sw = 255;
1607 if (sh > 255) sh = 255; 2151 if (sh > 255) sh = 255;
1608 2152
1609 // clear key, in case of extra padding 2153 // clear key, in case of extra padding
1610 memset (&skey, 0, sizeof (skey)); 2154 memset (&skey, 0, sizeof (skey));
1611 2155
1612 glColor4ub (255, 255, 255, 255); 2156 memset (&key, 0, sizeof (key));
1613 2157 key.r = 255;
1614 glEnable (GL_BLEND); 2158 key.g = 255;
1615 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2159 key.b = 255;
1616 glEnable (GL_TEXTURE_2D); 2160 key.a = 255;
1617 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2161 key.mode = GL_QUADS;
1618 2162 key.format = GL_T2F_V3F;
1619 glBegin (GL_QUADS);
1620
1621 last_name = 0;
1622 2163
1623 mx += self->x; 2164 mx += self->x;
1624 my += self->y; 2165 my += self->y;
1625 2166
1626 // first pass: determine smooth_max 2167 // first pass: determine smooth_max
1643 MAX (self->tex [cell->tile [1]].smoothlevel, 2184 MAX (self->tex [cell->tile [1]].smoothlevel,
1644 self->tex [cell->tile [2]].smoothlevel)); 2185 self->tex [cell->tile [2]].smoothlevel));
1645 } 2186 }
1646 } 2187 }
1647 2188
2189 glEnable (GL_BLEND);
2190 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2191 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2192
1648 for (z = 0; z <= 2; z++) 2193 for (z = 0; z <= 2; z++)
1649 { 2194 {
1650 memset (smooth_level, 0, sizeof (smooth_level)); 2195 memset (smooth_level, 0, sizeof (smooth_level));
2196 key.texname = -1;
1651 2197
1652 for (y = 0; y < sh; y++) 2198 for (y = 0; y < sh; y++)
1653 if (0 <= y + my && y + my < self->rows) 2199 if (0 <= y + my && y + my < self->rows)
1654 { 2200 {
1655 maprow *row = self->row + (y + my); 2201 maprow *row = self->row + (y + my);
1661 tileid tile = cell->tile [z]; 2207 tileid tile = cell->tile [z];
1662 2208
1663 if (tile) 2209 if (tile)
1664 { 2210 {
1665 maptex tex = self->tex [tile]; 2211 maptex tex = self->tex [tile];
1666 int px = (x + 1) * T - tex.w; 2212 int px, py;
1667 int py = (y + 1) * T - tex.h;
1668 2213
1669 // suppressing texture state switches here
1670 // is only moderately effective, but worth the extra effort
1671 if (last_name != tex.name) 2214 if (key.texname != tex.name)
1672 { 2215 {
2216 self->tex [tile].unused = 0;
2217
1673 if (!tex.name) 2218 if (!tex.name)
1674 tex = self->tex [2]; /* missing, replace by noface */ 2219 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1675 2220
1676 glEnd (); 2221 key.texname = tex.name;
1677 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2222 arr = rc_array (rc, &key);
1678 glBegin (GL_QUADS);
1679 } 2223 }
1680 2224
1681 glTexCoord2f (0 , 0 ); glVertex2f (px , py ); 2225 px = (x + 1) * T - tex.w;
1682 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h); 2226 py = (y + 1) * T - tex.h;
1683 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1684 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1685 2227
1686 if (cell->flags && z == 2) 2228 if (expect_false (cell->player == player) && expect_false (z == 2))
1687 { 2229 {
1688 if (cell->flags & 1) 2230 pl_x = px;
2231 pl_y = py;
2232 pl_tex = tex;
1689 { 2233 continue;
1690 maptex tex = self->tex [1];
1691 int px = x * T + T * 2 / 32;
1692 int py = y * T - T * 6 / 32;
1693
1694 glEnd ();
1695 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1696 glBegin (GL_QUADS);
1697
1698 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1699 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1700 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1701 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1702 }
1703 } 2234 }
2235
2236 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2237 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
2238 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
2239 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1704 2240
1705 // update smooth hash 2241 // update smooth hash
1706 if (tex.smoothtile) 2242 if (tex.smoothtile)
1707 { 2243 {
1708 skey.tile = tex.smoothtile; 2244 skey.tile = tex.smoothtile;
1739 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2275 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1740 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2276 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1741 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2277 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1742 } 2278 }
1743 } 2279 }
2280
2281 if (expect_false (z == 2) && expect_false (cell->flags))
2282 {
2283 // overlays such as the speech bubble, probably more to come
2284 if (cell->flags & 1)
2285 {
2286 rc_key_t key_ov = key;
2287 maptex tex = self->tex [TEXID_SPEECH];
2288 rc_array_t *arr;
2289 int px = x * T + T * 2 / 32;
2290 int py = y * T - T * 6 / 32;
2291
2292 key_ov.texname = tex.name;
2293 arr = rc_array (rc_ov, &key_ov);
2294
2295 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2296 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
2297 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
2298 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
2299 }
2300 }
1744 } 2301 }
1745 } 2302 }
2303
2304 rc_draw (rc);
2305 rc_clear (rc);
1746 2306
1747 // go through all smoothlevels, lowest to highest, then draw. 2307 // go through all smoothlevels, lowest to highest, then draw.
1748 // this is basically counting sort 2308 // this is basically counting sort
1749 { 2309 {
1750 int w, b; 2310 int w, b;
1751 2311
2312 glEnable (GL_TEXTURE_2D);
2313 glBegin (GL_QUADS);
1752 for (w = 0; w < 256 / 32; ++w) 2314 for (w = 0; w < 256 / 32; ++w)
1753 { 2315 {
1754 uint32_t smask = smooth_level [w]; 2316 uint32_t smask = smooth_level [w];
1755 if (smask) 2317 if (smask)
1756 for (b = 0; b < 32; ++b) 2318 for (b = 0; b < 32; ++b)
1775 int border = bits & 15; 2337 int border = bits & 15;
1776 int corner = (bits >> 8) & ~(bits >> 4) & 15; 2338 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1777 float dx = tex.s * .0625f; // 16 images/row 2339 float dx = tex.s * .0625f; // 16 images/row
1778 float dy = tex.t * .5f ; // 2 images/column 2340 float dy = tex.t * .5f ; // 2 images/column
1779 2341
1780 // this time naively avoiding texture state changes
1781 // save gobs of state changes.
1782 if (last_name != tex.name) 2342 if (tex.name)
1783 { 2343 {
2344 // this time avoiding texture state changes
2345 // save gobs of state changes.
1784 if (!tex.name) 2346 if (key.texname != tex.name)
1785 continue; // smoothing not yet available 2347 {
2348 self->tex [skey->tile].unused = 0;
1786 2349
1787 glEnd (); 2350 glEnd ();
1788 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2351 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1789 glBegin (GL_QUADS); 2352 glBegin (GL_QUADS);
1790 } 2353 }
1791 2354
1792 if (border) 2355 if (border)
1793 { 2356 {
1794 float ox = border * dx; 2357 float ox = border * dx;
1795 2358
1796 glTexCoord2f (ox , 0.f ); glVertex2f (px , py ); 2359 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1797 glTexCoord2f (ox , dy ); glVertex2f (px , py + T); 2360 glTexCoord2f (ox , dy ); glVertex2i (px , py + T);
1798 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T); 2361 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);
1799 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py ); 2362 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );
1800 } 2363 }
1801 2364
1802 if (corner) 2365 if (corner)
1803 { 2366 {
1804 float ox = corner * dx; 2367 float ox = corner * dx;
1805 2368
1806 glTexCoord2f (ox , dy ); glVertex2f (px , py ); 2369 glTexCoord2f (ox , dy ); glVertex2i (px , py );
1807 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T); 2370 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);
1808 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T); 2371 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);
1809 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py ); 2372 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );
2373 }
1810 } 2374 }
1811 } 2375 }
1812 } 2376 }
1813 } 2377 }
1814 } 2378 }
2379
2380 glEnd ();
2381 glDisable (GL_TEXTURE_2D);
2382 key.texname = -1;
1815 } 2383 }
1816 2384
1817 hv_clear (smooth); 2385 hv_clear (smooth);
1818 } 2386 }
1819 2387
1820 glEnd (); 2388 if (pl_tex.name)
2389 {
2390 maptex tex = pl_tex;
2391 int px = pl_x + sdx;
2392 int py = pl_y + sdy;
1821 2393
1822 glDisable (GL_TEXTURE_2D); 2394 key.texname = tex.name;
2395 arr = rc_array (rc, &key);
2396
2397 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2398 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
2399 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
2400 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2401
2402 rc_draw (rc);
2403 }
2404
2405 rc_draw (rc_ov);
2406 rc_clear (rc_ov);
2407
1823 glDisable (GL_BLEND); 2408 glDisable (GL_BLEND);
2409 rc_free (rc);
2410 rc_free (rc_ov);
1824 2411
1825 // top layer: overlays such as the health bar 2412 // top layer: overlays such as the health bar
1826 for (y = 0; y < sh; y++) 2413 for (y = 0; y < sh; y++)
1827 if (0 <= y + my && y + my < self->rows) 2414 if (0 <= y + my && y + my < self->rows)
1828 { 2415 {
1833 { 2420 {
1834 mapcell *cell = row->col + (x + mx - row->c0); 2421 mapcell *cell = row->col + (x + mx - row->c0);
1835 2422
1836 int px = x * T; 2423 int px = x * T;
1837 int py = y * T; 2424 int py = y * T;
2425
2426 if (expect_false (cell->player == player))
2427 {
2428 px += sdx;
2429 py += sdy;
2430 }
1838 2431
1839 if (cell->stat_hp) 2432 if (cell->stat_hp)
1840 { 2433 {
1841 int width = cell->stat_width * T; 2434 int width = cell->stat_width * T;
1842 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2435 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1853 } 2446 }
1854 } 2447 }
1855} 2448}
1856 2449
1857void 2450void
1858draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data) 2451draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
1859 CODE: 2452 CODE:
1860{ 2453{
1861 static float color[16][3] = { 2454 static float color[16][3] = {
1862 { 0.00F, 0.00F, 0.00F }, 2455 { 0.00f, 0.00f, 0.00f },
1863 { 1.00F, 1.00F, 1.00F }, 2456 { 1.00f, 1.00f, 1.00f },
1864 { 0.00F, 0.00F, 0.55F }, 2457 { 0.00f, 0.00f, 0.55f },
1865 { 1.00F, 0.00F, 0.00F }, 2458 { 1.00f, 0.00f, 0.00f },
1866 2459
1867 { 1.00F, 0.54F, 0.00F }, 2460 { 1.00f, 0.54f, 0.00f },
1868 { 0.11F, 0.56F, 1.00F }, 2461 { 0.11f, 0.56f, 1.00f },
1869 { 0.93F, 0.46F, 0.00F }, 2462 { 0.93f, 0.46f, 0.00f },
1870 { 0.18F, 0.54F, 0.34F }, 2463 { 0.18f, 0.54f, 0.34f },
1871 2464
1872 { 0.56F, 0.73F, 0.56F }, 2465 { 0.56f, 0.73f, 0.56f },
1873 { 0.80F, 0.80F, 0.80F }, 2466 { 0.80f, 0.80f, 0.80f },
1874 { 0.55F, 0.41F, 0.13F }, 2467 { 0.55f, 0.41f, 0.13f },
1875 { 0.99F, 0.77F, 0.26F }, 2468 { 0.99f, 0.77f, 0.26f },
1876 2469
1877 { 0.74F, 0.65F, 0.41F }, 2470 { 0.74f, 0.65f, 0.41f },
1878 2471
1879 { 0.00F, 1.00F, 1.00F }, 2472 { 0.00f, 1.00f, 1.00f },
1880 { 1.00F, 0.00F, 1.00F }, 2473 { 1.00f, 0.00f, 1.00f },
1881 { 1.00F, 1.00F, 0.00F }, 2474 { 1.00f, 1.00f, 0.00f },
1882 }; 2475 };
1883 2476
1884 int x, y; 2477 int x, y;
1885 2478
1886 glEnable (GL_TEXTURE_2D); 2479 glEnable (GL_TEXTURE_2D);
2480 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2481 * but the nvidia driver (185.18.14) mishandles alpha textures
2482 * and takes the colour from god knows where instead of using
2483 * Cp. MODULATE results in the same colour, but slightly different
2484 * alpha, but atcually gives us the correct colour with nvidia.
2485 */
1887 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2486 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1888 glEnable (GL_BLEND); 2487 glEnable (GL_BLEND);
1889 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2488 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1890 glBegin (GL_QUADS); 2489 glBegin (GL_QUADS);
1891 2490
1892 for (y = 0; y < h; y++) 2491 for (y = 0; y < h; y++)
1896 2495
1897 if (m) 2496 if (m)
1898 { 2497 {
1899 float *c = color [m & 15]; 2498 float *c = color [m & 15];
1900 2499
1901 float tx1 = m & 0x40 ? 0.5 : 0.; 2500 float tx1 = m & 0x40 ? 0.5f : 0.f;
1902 float tx2 = tx1 + 0.5; 2501 float tx2 = tx1 + 0.5f;
1903 2502
1904 glColor4f (c[0], c[1], c[2], 0.75); 2503 glColor4f (c[0], c[1], c[2], 1);
1905 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2504 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
1906 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2505 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
1907 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2506 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
1908 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2507 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
1909 } 2508 }
1913 glDisable (GL_BLEND); 2512 glDisable (GL_BLEND);
1914 glDisable (GL_TEXTURE_2D); 2513 glDisable (GL_TEXTURE_2D);
1915} 2514}
1916 2515
1917void 2516void
1918fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh) 2517fow_texture (DC::Map self, int mx, int my, int sw, int sh)
1919 PPCODE: 2518 PPCODE:
1920{ 2519{
1921 int x, y; 2520 int x, y;
1922 int sw4 = (sw + 3) & ~3; 2521 int sw1 = sw + 2;
2522 int sh1 = sh + 2;
2523 int sh3 = sh * 3;
2524 int sw3 = sw * 3;
2525 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
1923 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2526 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
1924 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2527 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1925 2528
1926 memset (darkness, 255, sw4 * sh);
1927 SvPOK_only (darkness_sv); 2529 SvPOK_only (darkness3_sv);
1928 SvCUR_set (darkness_sv, sw4 * sh); 2530 SvCUR_set (darkness3_sv, sw3 * sh3);
1929 2531
1930 mx += self->x; 2532 mx += self->x - 1;
1931 my += self->y; 2533 my += self->y - 1;
1932 2534
1933 for (y = 0; y < sh; y++) 2535 for (y = 0; y < sh1; y++)
1934 if (0 <= y + my && y + my < self->rows) 2536 if (0 <= y + my && y + my < self->rows)
1935 { 2537 {
1936 maprow *row = self->row + (y + my); 2538 maprow *row = self->row + (y + my);
1937 2539
1938 for (x = 0; x < sw; x++) 2540 for (x = 0; x < sw1; x++)
1939 if (row->c0 <= x + mx && x + mx < row->c1) 2541 if (row->c0 <= x + mx && x + mx < row->c1)
1940 { 2542 {
1941 mapcell *cell = row->col + (x + mx - row->c0); 2543 mapcell *cell = row->col + (x + mx - row->c0);
1942 2544
1943 darkness[y * sw4 + x] = cell->darkness 2545 darkness1 [y * sw1 + x] = cell->darkness
1944 ? 255 - (cell->darkness - 1) 2546 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
1945 : 255 - FOW_DARKNESS; 2547 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
1946 } 2548 }
1947 } 2549 }
1948 2550
2551 for (y = 0; y < sh; ++y)
2552 for (x = 0; x < sw; ++x)
2553 {
2554 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2555 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2556 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2557 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2558 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2559 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2560 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2561 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2562 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2563
2564 uint8_t r11 = (d11 + d21 + d12) / 3;
2565 uint8_t r21 = d21;
2566 uint8_t r31 = (d21 + d31 + d32) / 3;
2567
2568 uint8_t r12 = d12;
2569 uint8_t r22 = d22;
2570 uint8_t r32 = d32;
2571
2572 uint8_t r13 = (d13 + d23 + d12) / 3;
2573 uint8_t r23 = d23;
2574 uint8_t r33 = (d23 + d33 + d32) / 3;
2575
2576 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2577 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2578 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2579 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2580 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2581 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2582 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2583 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2584 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2585 }
2586
2587 free (darkness1);
2588
1949 EXTEND (SP, 3); 2589 EXTEND (SP, 3);
1950 PUSHs (sv_2mortal (newSViv (sw4))); 2590 PUSHs (sv_2mortal (newSViv (sw3)));
1951 PUSHs (sv_2mortal (newSViv (sh))); 2591 PUSHs (sv_2mortal (newSViv (sh3)));
1952 PUSHs (darkness_sv); 2592 PUSHs (darkness3_sv);
1953} 2593}
1954 2594
1955SV * 2595SV *
1956get_rect (CFPlus::Map self, int x0, int y0, int w, int h) 2596get_rect (DC::Map self, int x0, int y0, int w, int h)
1957 CODE: 2597 CODE:
1958{ 2598{
1959 int x, y, x1, y1; 2599 int x, y, x1, y1;
1960 SV *data_sv = newSV (w * h * 7 + 5); 2600 SV *data_sv = newSV (w * h * 7 + 5);
1961 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2601 uint8_t *data = (uint8_t *)SvPVX (data_sv);
2018 else 2658 else
2019 *data++ = 0; 2659 *data++ = 0;
2020 } 2660 }
2021 } 2661 }
2022 2662
2663 /* if size is w*h + 5 then no data has been found */
2664 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2665 {
2023 SvPOK_only (data_sv); 2666 SvPOK_only (data_sv);
2024 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2667 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2668 }
2669
2025 RETVAL = data_sv; 2670 RETVAL = data_sv;
2026} 2671}
2027 OUTPUT: 2672 OUTPUT:
2028 RETVAL 2673 RETVAL
2029 2674
2030void 2675void
2031set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2676set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2032 PPCODE: 2677 PPCODE:
2033{ 2678{
2034 int x, y, z; 2679 int x, y, z;
2035 int w, h; 2680 int w, h;
2036 int x1, y1; 2681 int x1, y1;
2682 STRLEN len;
2683 uint8_t *data, *end;
2684
2685 len = SvLEN (data_sv);
2686 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2687 data = SvPVbyte_nolen (data_sv);
2688 end = data + len + 8;
2689
2690 if (len < 5)
2691 XSRETURN_EMPTY;
2037 2692
2038 if (*data++ != 0) 2693 if (*data++ != 0)
2039 return; /* version mismatch */ 2694 XSRETURN_EMPTY; /* version mismatch */
2040 2695
2041 w = *data++ << 8; w |= *data++; 2696 w = *data++ << 8; w |= *data++;
2042 h = *data++ << 8; h |= *data++; 2697 h = *data++ << 8; h |= *data++;
2043 2698
2044 // we need to do this 'cause we don't keep an absolute coord system for rows 2699 // we need to do this 'cause we don't keep an absolute coord system for rows
2056 { 2711 {
2057 maprow *row = map_get_row (self, y); 2712 maprow *row = map_get_row (self, y);
2058 2713
2059 for (x = x0; x < x1; x++) 2714 for (x = x0; x < x1; x++)
2060 { 2715 {
2716 uint8_t flags;
2717
2718 if (data + 7 >= end)
2719 XSRETURN_EMPTY;
2720
2061 uint8_t flags = *data++; 2721 flags = *data++;
2062 2722
2063 if (flags) 2723 if (flags)
2064 { 2724 {
2065 mapcell *cell = row_get_cell (row, x); 2725 mapcell *cell = row_get_cell (row, x);
2066 tileid tile[3] = { 0, 0, 0 }; 2726 tileid tile[3] = { 0, 0, 0 };
2069 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2729 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2070 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2730 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2071 2731
2072 if (cell->darkness == 0) 2732 if (cell->darkness == 0)
2073 { 2733 {
2074 cell->darkness = 0; 2734 /*cell->darkness = 0;*/
2735 EXTEND (SP, 3);
2075 2736
2076 for (z = 0; z <= 2; z++) 2737 for (z = 0; z <= 2; z++)
2077 { 2738 {
2078 tileid t = tile [z]; 2739 tileid t = tile [z];
2079 2740
2080 if (t >= self->texs || (t && !self->tex [t].name)) 2741 if (t >= self->texs || (t && !self->tex [t].name))
2081 { 2742 {
2082 XPUSHs (sv_2mortal (newSViv (t))); 2743 PUSHs (sv_2mortal (newSViv (t)));
2083 need_texid (self, t); 2744 need_texid (self, t);
2084 } 2745 }
2085 2746
2086 cell->tile [z] = t; 2747 cell->tile [z] = t;
2087 } 2748 }
2089 } 2750 }
2090 } 2751 }
2091 } 2752 }
2092} 2753}
2093 2754
2094MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2755MODULE = Deliantra::Client PACKAGE = DC::RW
2095 2756
2096CFPlus::MixChunk 2757DC::RW
2097new_from_file (SV *class, char *path) 2758new (SV *class, SV *data_sv)
2098 CODE: 2759 CODE:
2099 RETVAL = Mix_LoadWAV (path); 2760{
2761 STRLEN datalen;
2762 char *data = SvPVbyte (data_sv, datalen);
2763
2764 RETVAL = SDL_RWFromConstMem (data, datalen);
2765}
2100 OUTPUT: 2766 OUTPUT:
2101 RETVAL 2767 RETVAL
2102 2768
2769DC::RW
2770new_from_file (SV *class, const char *path, const char *mode = "rb")
2771 CODE:
2772 RETVAL = SDL_RWFromFile (path, mode);
2773 OUTPUT:
2774 RETVAL
2775
2776# fails on win32:
2777# dc.xs(2268) : error C2059: syntax error : '('
2103void 2778#void
2779#close (DC::RW self)
2780# CODE:
2781# (self->(close)) (self);
2782
2783MODULE = Deliantra::Client PACKAGE = DC::Channel
2784
2785PROTOTYPES: DISABLE
2786
2787DC::Channel
2788find ()
2789 CODE:
2790{
2791 RETVAL = Mix_GroupAvailable (-1);
2792
2793 if (RETVAL < 0)
2794 {
2795 RETVAL = Mix_GroupOldest (-1);
2796
2797 if (RETVAL < 0)
2798 XSRETURN_UNDEF;
2799
2800 Mix_HaltChannel (RETVAL);
2801 }
2802
2803 Mix_UnregisterAllEffects (RETVAL);
2804 Mix_Volume (RETVAL, 128);
2805}
2806 OUTPUT:
2807 RETVAL
2808
2809void
2810halt (DC::Channel self)
2811 CODE:
2812 Mix_HaltChannel (self);
2813
2814void
2815expire (DC::Channel self, int ticks = -1)
2816 CODE:
2817 Mix_ExpireChannel (self, ticks);
2818
2819void
2820fade_out (DC::Channel self, int ticks = -1)
2821 CODE:
2822 Mix_FadeOutChannel (self, ticks);
2823
2824int
2825volume (DC::Channel self, int volume)
2826 CODE:
2827 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2828 OUTPUT:
2829 RETVAL
2830
2831void
2832unregister_all_effects (DC::Channel self)
2833 CODE:
2834 Mix_UnregisterAllEffects (self);
2835
2836void
2837set_panning (DC::Channel self, int left, int right)
2838 CODE:
2839 left = CLAMP (left , 0, 255);
2840 right = CLAMP (right, 0, 255);
2841 Mix_SetPanning (self, left, right);
2842
2843void
2844set_distance (DC::Channel self, int distance)
2845 CODE:
2846 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2847
2848void
2849set_position (DC::Channel self, int angle, int distance)
2850 CODE:
2851
2852void
2853set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2854 CODE:
2855{
2856 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2857 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2858 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2859}
2860
2861void
2862set_reverse_stereo (DC::Channel self, int flip)
2863 CODE:
2864 Mix_SetReverseStereo (self, flip);
2865
2866MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2867
2868PROTOTYPES: DISABLE
2869
2870DC::MixChunk
2871new (SV *class, DC::RW rwops)
2872 CODE:
2873 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2874 OUTPUT:
2875 RETVAL
2876
2877void
2104DESTROY (CFPlus::MixChunk self) 2878DESTROY (DC::MixChunk self)
2105 CODE: 2879 CODE:
2106 Mix_FreeChunk (self); 2880 Mix_FreeChunk (self);
2107 2881
2108int 2882int
2109volume (CFPlus::MixChunk self, int volume = -1) 2883volume (DC::MixChunk self, int volume = -1)
2110 CODE: 2884 CODE:
2885 if (items > 1)
2886 volume = CLAMP (volume, 0, 128);
2111 RETVAL = Mix_VolumeChunk (self, volume); 2887 RETVAL = Mix_VolumeChunk (self, volume);
2112 OUTPUT: 2888 OUTPUT:
2113 RETVAL 2889 RETVAL
2114 2890
2115int 2891DC::Channel
2116play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1) 2892play (DC::MixChunk self, DC::Channel channel = -1, int loops = 0, int ticks = -1)
2117 CODE: 2893 CODE:
2894{
2118 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2895 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2896
2897 if (RETVAL < 0)
2898 XSRETURN_UNDEF;
2899
2900 if (channel < 0)
2901 {
2902 Mix_UnregisterAllEffects (RETVAL);
2903 Mix_Volume (RETVAL, 128);
2904 }
2905}
2119 OUTPUT: 2906 OUTPUT:
2120 RETVAL 2907 RETVAL
2121 2908
2122MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2909MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2123 2910
2124int 2911int
2125volume (int volume = -1) 2912volume (int volume = -1)
2913 PROTOTYPE: ;$
2126 CODE: 2914 CODE:
2915 if (items > 0)
2916 volume = CLAMP (volume, 0, 128);
2127 RETVAL = Mix_VolumeMusic (volume); 2917 RETVAL = Mix_VolumeMusic (volume);
2128 OUTPUT: 2918 OUTPUT:
2129 RETVAL 2919 RETVAL
2130 2920
2921void
2922fade_out (int ms)
2923 CODE:
2924 Mix_FadeOutMusic (ms);
2925
2926void
2927halt ()
2928 CODE:
2929 Mix_HaltMusic ();
2930
2131CFPlus::MixMusic 2931DC::MixMusic
2132new_from_file (SV *class, char *path) 2932new (SV *class, DC::RW rwops)
2133 CODE: 2933 CODE:
2134 RETVAL = Mix_LoadMUS (path); 2934 RETVAL = Mix_LoadMUS_RW (rwops);
2135 OUTPUT: 2935 OUTPUT:
2136 RETVAL 2936 RETVAL
2137 2937
2138void 2938void
2139DESTROY (CFPlus::MixMusic self) 2939DESTROY (DC::MixMusic self)
2140 CODE: 2940 CODE:
2141 Mix_FreeMusic (self); 2941 Mix_FreeMusic (self);
2142 2942
2143int 2943int
2144play (CFPlus::MixMusic self, int loops = -1) 2944play (DC::MixMusic self, int loops = -1)
2145 CODE: 2945 CODE:
2146 RETVAL = Mix_PlayMusic (self, loops); 2946 RETVAL = Mix_PlayMusic (self, loops);
2147 OUTPUT: 2947 OUTPUT:
2148 RETVAL 2948 RETVAL
2149 2949
2150MODULE = CFPlus PACKAGE = CFPlus::OpenGL 2950void
2951fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2952 CODE:
2953 Mix_FadeInMusicPos (self, loops, ms, position);
2954
2955MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2956
2957PROTOTYPES: ENABLE
2151 2958
2152BOOT: 2959BOOT:
2153{ 2960{
2154 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 2961 HV *stash = gv_stashpv ("DC::OpenGL", 1);
2155 static const struct { 2962 static const struct {
2156 const char *name; 2963 const char *name;
2157 IV iv; 2964 IV iv;
2158 } *civ, const_iv[] = { 2965 } *civ, const_iv[] = {
2159# define const_iv(name) { # name, (IV)name } 2966# define const_iv(name) { # name, (IV)name }
2967 const_iv (GL_VENDOR),
2968 const_iv (GL_VERSION),
2969 const_iv (GL_EXTENSIONS),
2970 const_iv (GL_MAX_TEXTURE_UNITS),
2160 const_iv (GL_COLOR_MATERIAL), 2971 const_iv (GL_COLOR_MATERIAL),
2161 const_iv (GL_SMOOTH), 2972 const_iv (GL_SMOOTH),
2162 const_iv (GL_FLAT), 2973 const_iv (GL_FLAT),
2163 const_iv (GL_DITHER), 2974 const_iv (GL_DITHER),
2164 const_iv (GL_BLEND), 2975 const_iv (GL_BLEND),
2168 const_iv (GL_ALPHA_TEST), 2979 const_iv (GL_ALPHA_TEST),
2169 const_iv (GL_NORMALIZE), 2980 const_iv (GL_NORMALIZE),
2170 const_iv (GL_RESCALE_NORMAL), 2981 const_iv (GL_RESCALE_NORMAL),
2171 const_iv (GL_FRONT), 2982 const_iv (GL_FRONT),
2172 const_iv (GL_BACK), 2983 const_iv (GL_BACK),
2984 const_iv (GL_AUX0),
2173 const_iv (GL_AND), 2985 const_iv (GL_AND),
2174 const_iv (GL_ONE), 2986 const_iv (GL_ONE),
2175 const_iv (GL_ZERO), 2987 const_iv (GL_ZERO),
2176 const_iv (GL_SRC_ALPHA), 2988 const_iv (GL_SRC_ALPHA),
2177 const_iv (GL_DST_ALPHA), 2989 const_iv (GL_DST_ALPHA),
2178 const_iv (GL_ONE_MINUS_SRC_ALPHA), 2990 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2179 const_iv (GL_ONE_MINUS_DST_ALPHA), 2991 const_iv (GL_ONE_MINUS_DST_ALPHA),
2992 const_iv (GL_SRC_COLOR),
2993 const_iv (GL_DST_COLOR),
2994 const_iv (GL_ONE_MINUS_SRC_COLOR),
2995 const_iv (GL_ONE_MINUS_DST_COLOR),
2180 const_iv (GL_SRC_ALPHA_SATURATE), 2996 const_iv (GL_SRC_ALPHA_SATURATE),
2181 const_iv (GL_RGB), 2997 const_iv (GL_RGB),
2182 const_iv (GL_RGBA), 2998 const_iv (GL_RGBA),
2183 const_iv (GL_RGBA4), 2999 const_iv (GL_RGBA4),
2184 const_iv (GL_RGBA8), 3000 const_iv (GL_RGBA8),
2190 const_iv (GL_INTENSITY), 3006 const_iv (GL_INTENSITY),
2191 const_iv (GL_LUMINANCE), 3007 const_iv (GL_LUMINANCE),
2192 const_iv (GL_LUMINANCE_ALPHA), 3008 const_iv (GL_LUMINANCE_ALPHA),
2193 const_iv (GL_FLOAT), 3009 const_iv (GL_FLOAT),
2194 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV), 3010 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
3011 const_iv (GL_COMPRESSED_ALPHA_ARB),
3012 const_iv (GL_COMPRESSED_LUMINANCE_ARB),
3013 const_iv (GL_COMPRESSED_LUMINANCE_ALPHA_ARB),
3014 const_iv (GL_COMPRESSED_INTENSITY_ARB),
3015 const_iv (GL_COMPRESSED_RGB_ARB),
3016 const_iv (GL_COMPRESSED_RGBA_ARB),
2195 const_iv (GL_COMPILE), 3017 const_iv (GL_COMPILE),
3018 const_iv (GL_PROXY_TEXTURE_1D),
3019 const_iv (GL_PROXY_TEXTURE_2D),
2196 const_iv (GL_TEXTURE_1D), 3020 const_iv (GL_TEXTURE_1D),
2197 const_iv (GL_TEXTURE_2D), 3021 const_iv (GL_TEXTURE_2D),
2198 const_iv (GL_TEXTURE_ENV), 3022 const_iv (GL_TEXTURE_ENV),
2199 const_iv (GL_TEXTURE_MAG_FILTER), 3023 const_iv (GL_TEXTURE_MAG_FILTER),
2200 const_iv (GL_TEXTURE_MIN_FILTER), 3024 const_iv (GL_TEXTURE_MIN_FILTER),
2221 const_iv (GL_COLOR_LOGIC_OP), 3045 const_iv (GL_COLOR_LOGIC_OP),
2222 const_iv (GL_SEPARABLE_2D), 3046 const_iv (GL_SEPARABLE_2D),
2223 const_iv (GL_CONVOLUTION_2D), 3047 const_iv (GL_CONVOLUTION_2D),
2224 const_iv (GL_CONVOLUTION_BORDER_MODE), 3048 const_iv (GL_CONVOLUTION_BORDER_MODE),
2225 const_iv (GL_CONSTANT_BORDER), 3049 const_iv (GL_CONSTANT_BORDER),
3050 const_iv (GL_POINTS),
2226 const_iv (GL_LINES), 3051 const_iv (GL_LINES),
2227 const_iv (GL_LINE_STRIP), 3052 const_iv (GL_LINE_STRIP),
2228 const_iv (GL_LINE_LOOP), 3053 const_iv (GL_LINE_LOOP),
2229 const_iv (GL_QUADS), 3054 const_iv (GL_QUADS),
2230 const_iv (GL_QUAD_STRIP), 3055 const_iv (GL_QUAD_STRIP),
2231 const_iv (GL_TRIANGLES), 3056 const_iv (GL_TRIANGLES),
2232 const_iv (GL_TRIANGLE_STRIP), 3057 const_iv (GL_TRIANGLE_STRIP),
2233 const_iv (GL_TRIANGLE_FAN), 3058 const_iv (GL_TRIANGLE_FAN),
3059 const_iv (GL_POLYGON),
2234 const_iv (GL_PERSPECTIVE_CORRECTION_HINT), 3060 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
3061 const_iv (GL_POINT_SMOOTH_HINT),
3062 const_iv (GL_LINE_SMOOTH_HINT),
3063 const_iv (GL_POLYGON_SMOOTH_HINT),
3064 const_iv (GL_GENERATE_MIPMAP_HINT),
3065 const_iv (GL_TEXTURE_COMPRESSION_HINT),
2235 const_iv (GL_FASTEST), 3066 const_iv (GL_FASTEST),
3067 const_iv (GL_DONT_CARE),
3068 const_iv (GL_NICEST),
2236 const_iv (GL_V2F), 3069 const_iv (GL_V2F),
2237 const_iv (GL_V3F), 3070 const_iv (GL_V3F),
2238 const_iv (GL_T2F_V3F), 3071 const_iv (GL_T2F_V3F),
2239 const_iv (GL_T2F_N3F_V3F), 3072 const_iv (GL_T2F_N3F_V3F),
3073 const_iv (GL_FUNC_ADD),
3074 const_iv (GL_FUNC_SUBTRACT),
3075 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2240# undef const_iv 3076# undef const_iv
2241 }; 3077 };
2242 3078
2243 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3079 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2244 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3080 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2245 3081
2246 texture_av = newAV (); 3082 texture_av = newAV ();
2247 AvREAL_off (texture_av); 3083 AvREAL_off (texture_av);
2248} 3084}
2249 3085
3086void
3087disable_GL_EXT_blend_func_separate ()
3088 CODE:
3089 gl.BlendFuncSeparate = 0;
3090 gl.BlendFuncSeparateEXT = 0;
3091
3092void
3093apple_nvidia_bug (int enable)
3094
2250char * 3095char *
2251gl_vendor () 3096gl_vendor ()
2252 CODE: 3097 CODE:
2253 RETVAL = (char *)glGetString (GL_VENDOR); 3098 RETVAL = (char *)glGetString (GL_VENDOR);
2254 OUTPUT: 3099 OUTPUT:
2266 CODE: 3111 CODE:
2267 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3112 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2268 OUTPUT: 3113 OUTPUT:
2269 RETVAL 3114 RETVAL
2270 3115
3116const char *glGetString (GLenum pname)
3117
3118GLint glGetInteger (GLenum pname)
3119 CODE:
3120 glGetIntegerv (pname, &RETVAL);
3121 OUTPUT:
3122 RETVAL
3123
3124GLdouble glGetDouble (GLenum pname)
3125 CODE:
3126 glGetDoublev (pname, &RETVAL);
3127 OUTPUT:
3128 RETVAL
3129
2271int glGetError () 3130int glGetError ()
2272 3131
2273void glFinish () 3132void glFinish ()
2274 3133
2275void glClear (int mask) 3134void glClear (int mask)
2289 3148
2290void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3149void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2291 CODE: 3150 CODE:
2292 gl_BlendFuncSeparate (sa, da, saa, daa); 3151 gl_BlendFuncSeparate (sa, da, saa, daa);
2293 3152
3153# void glBlendEquation (int se)
3154
2294void glDepthMask (int flag) 3155void glDepthMask (int flag)
2295 3156
2296void glLogicOp (int opcode) 3157void glLogicOp (int opcode)
2297 3158
2298void glColorMask (int red, int green, int blue, int alpha) 3159void glColorMask (int red, int green, int blue, int alpha)
2312# near_ and far_ are due to microsofts buggy "c" compiler 3173# near_ and far_ are due to microsofts buggy "c" compiler
2313void glFrustum (double left, double right, double bottom, double top, double near_, double far_) 3174void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
2314 3175
2315# near_ and far_ are due to microsofts buggy "c" compiler 3176# near_ and far_ are due to microsofts buggy "c" compiler
2316void glOrtho (double left, double right, double bottom, double top, double near_, double far_) 3177void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
3178
3179PROTOTYPES: DISABLE
2317 3180
2318void glViewport (int x, int y, int width, int height) 3181void glViewport (int x, int y, int width, int height)
2319 3182
2320void glScissor (int x, int y, int width, int height) 3183void glScissor (int x, int y, int width, int height)
2321 3184
2329 3192
2330void glRotate (float angle, float x, float y, float z) 3193void glRotate (float angle, float x, float y, float z)
2331 CODE: 3194 CODE:
2332 glRotatef (angle, x, y, z); 3195 glRotatef (angle, x, y, z);
2333 3196
2334void glBegin (int mode)
2335
2336void glEnd ()
2337
2338void glColor (float r, float g, float b, float a = 1.0) 3197void glColor (float r, float g, float b, float a = 1.0)
2339 PROTOTYPE: @ 3198 PROTOTYPE: @
2340 ALIAS: 3199 ALIAS:
2341 glColor_premultiply = 1 3200 glColor_premultiply = 1
2342 CODE: 3201 CODE:
2343 if (ix) 3202 if (ix)
2344 { 3203 {
2347 b *= a; 3206 b *= a;
2348 } 3207 }
2349 // microsoft visual "c" rounds instead of truncating... 3208 // microsoft visual "c" rounds instead of truncating...
2350 glColor4f (r, g, b, a); 3209 glColor4f (r, g, b, a);
2351 3210
2352void glInterleavedArrays (int format, int stride, char *data)
2353
2354void glDrawElements (int mode, int count, int type, char *indices)
2355
2356# 1.2 void glDrawRangeElements (int mode, int start, int end
2357
2358void glRasterPos (float x, float y, float z = 0.) 3211void glRasterPos (float x, float y, float z = 0.)
2359 CODE: 3212 CODE:
2360 glRasterPos3f (0, 0, z); 3213 glRasterPos3f (0, 0, z);
2361 glBitmap (0, 0, 0, 0, x, y, 0); 3214 glBitmap (0, 0, 0, 0, x, y, 0);
2362 3215
2366 3219
2367void glTexCoord (float s, float t) 3220void glTexCoord (float s, float t)
2368 CODE: 3221 CODE:
2369 glTexCoord2f (s, t); 3222 glTexCoord2f (s, t);
2370 3223
3224void glRect (float x1, float y1, float x2, float y2)
3225 CODE:
3226 glRectf (x1, y1, x2, y2);
3227
3228void glRect_lineloop (float x1, float y1, float x2, float y2)
3229 CODE:
3230 glBegin (GL_LINE_LOOP);
3231 glVertex2f (x1, y1);
3232 glVertex2f (x2, y1);
3233 glVertex2f (x2, y2);
3234 glVertex2f (x1, y2);
3235 glEnd ();
3236
3237PROTOTYPES: ENABLE
3238
3239void glBegin (int mode)
3240
3241void glEnd ()
3242
3243void glPointSize (GLfloat size)
3244
3245void glLineWidth (GLfloat width)
3246
3247void glInterleavedArrays (int format, int stride, char *data)
3248
3249void glDrawElements (int mode, int count, int type, char *indices)
3250
3251# 1.2 void glDrawRangeElements (int mode, int start, int end
3252
2371void glTexEnv (int target, int pname, float param) 3253void glTexEnv (int target, int pname, float param)
2372 CODE: 3254 CODE:
2373 glTexEnvf (target, pname, param); 3255 glTexEnvf (target, pname, param);
2374 3256
2375void glTexParameter (int target, int pname, float param) 3257void glTexParameter (int target, int pname, float param)
2391void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column) 3273void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2392 CODE: 3274 CODE:
2393 if (gl.SeparableFilter2D) 3275 if (gl.SeparableFilter2D)
2394 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3276 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2395 3277
2396void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data) 3278void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data = 0)
2397 3279
2398void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 3280void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2399 3281
2400void glDrawPixels (int width, int height, int format, int type, char *pixels) 3282void glDrawPixels (int width, int height, int format, int type, char *pixels)
3283
3284void glPixelZoom (float x, float y)
2401 3285
2402void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 3286void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2403 3287
2404int glGenTexture () 3288int glGenTexture ()
2405 CODE: 3289 CODE:
2425 3309
2426void glEndList () 3310void glEndList ()
2427 3311
2428void glCallList (int list) 3312void glCallList (int list)
2429 3313
3314void c_init ()
3315 CODE:
3316 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3317 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3318
3319MODULE = Deliantra::Client PACKAGE = DC::UI::Base
3320
3321PROTOTYPES: DISABLE
3322
3323void
3324find_widget (SV *self, NV x, NV y)
3325 PPCODE:
3326{
3327 if (within_widget (self, x, y))
3328 XPUSHs (self);
3329}
3330
3331BOOT:
3332{
3333 hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
3334
3335 draw_x_gv = gv_fetchpv ("DC::UI::Base::draw_x", 1, SVt_NV);
3336 draw_y_gv = gv_fetchpv ("DC::UI::Base::draw_y", 1, SVt_NV);
3337 draw_w_gv = gv_fetchpv ("DC::UI::Base::draw_w", 1, SVt_NV);
3338 draw_h_gv = gv_fetchpv ("DC::UI::Base::draw_h", 1, SVt_NV);
3339}
3340
3341void
3342draw (SV *self)
3343 CODE:
3344{
3345 HV *hv;
3346 SV **svp;
3347 NV x, y, w, h;
3348 SV *draw_x_sv = GvSV (draw_x_gv);
3349 SV *draw_y_sv = GvSV (draw_y_gv);
3350 SV *draw_w_sv = GvSV (draw_w_gv);
3351 SV *draw_h_sv = GvSV (draw_h_gv);
3352 double draw_x, draw_y;
3353
3354 if (!SvROK (self))
3355 croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
3356
3357 hv = (HV *)SvRV (self);
3358
3359 if (SvTYPE (hv) != SVt_PVHV)
3360 croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
3361
3362 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
3363 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
3364
3365 if (!h || !w)
3366 XSRETURN_EMPTY;
3367
3368 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
3369 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
3370
3371 draw_x = SvNV (draw_x_sv) + x;
3372 draw_y = SvNV (draw_y_sv) + y;
3373
3374 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
3375 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
3376 XSRETURN_EMPTY;
3377
3378 sv_setnv (draw_x_sv, draw_x);
3379 sv_setnv (draw_y_sv, draw_y);
3380
3381 glPushMatrix ();
3382 glTranslated (x, y, 0);
3383
3384 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
3385 {
3386 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
3387
3388 if (svp && SvTRUE (*svp))
3389 {
3390 glColor4f (1.0f * 0.2f, 0.8f * 0.2f, 0.5f * 0.2f, 0.2f);
3391 glEnable (GL_BLEND);
3392 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
3393 glBegin (GL_QUADS);
3394 glVertex2f (0, 0);
3395 glVertex2f (w, 0);
3396 glVertex2f (w, h);
3397 glVertex2f (0, h);
3398 glEnd ();
3399 glDisable (GL_BLEND);
3400 }
3401 }
3402#if 0
3403 // draw borders, for debugging
3404 glPushMatrix ();
3405 glColor4f (1., 1., 0., 1.);
3406 glTranslatef (.5, .5, 0.);
3407 glBegin (GL_LINE_LOOP);
3408 glVertex2f (0 , 0);
3409 glVertex2f (w - 1, 0);
3410 glVertex2f (w - 1, h - 1);
3411 glVertex2f (0 , h - 1);
3412 glEnd ();
3413 glPopMatrix ();
3414#endif
3415 PUSHMARK (SP);
3416 XPUSHs (self);
3417 PUTBACK;
3418 call_method ("_draw", G_VOID | G_DISCARD);
3419 SPAGAIN;
3420
3421 glPopMatrix ();
3422
3423 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
3424 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
3425}
3426

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines