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.203 by root, Thu Jul 19 13:45:16 2007 UTC vs.
Revision 1.297 by root, Tue Dec 22 00:08:11 2009 UTC

… …
17#include "perl.h" 17#include "perl.h"
18#include "XSUB.h" 18#include "XSUB.h"
19 19
20#ifdef _WIN32 20#ifdef _WIN32
21# 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
22#endif 26#endif
23 27
24#include <assert.h> 28#include <assert.h>
25#include <math.h> 29#include <math.h>
26#include <string.h> 30#include <string.h>
27#include <stdio.h> 31#include <stdio.h>
28#include <stdlib.h> 32#include <stdlib.h>
33
34#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
29 35
30#include <SDL.h> 36#include <SDL.h>
31#include <SDL_thread.h> 37#include <SDL_thread.h>
32#include <SDL_endian.h> 38#include <SDL_endian.h>
33#include <SDL_image.h> 39#include <SDL_image.h>
34#include <SDL_mixer.h> 40#include <SDL_mixer.h>
35#include <SDL_opengl.h> 41#include <SDL_opengl.h>
36 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
37#define PANGO_ENABLE_BACKEND 48#define PANGO_ENABLE_BACKEND
38#define G_DISABLE_CAST_CHECKS 49#define G_DISABLE_CAST_CHECKS
39 50
40#include <glib/gmacros.h> 51#include <glib/gmacros.h>
41 52
42#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
43 65
44#ifndef _WIN32 66#ifndef _WIN32
45# include <sys/types.h> 67# include <sys/types.h>
46# include <sys/socket.h> 68# include <sys/socket.h>
47# include <netinet/in.h> 69# include <netinet/in.h>
48# include <netinet/tcp.h> 70# include <netinet/tcp.h>
49# include <inttypes.h> 71# include <inttypes.h>
50#endif 72#endif
51 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
52#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 83#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
53 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 */
54#define FOW_DARKNESS 32 87#define FOW_DARKNESS 50
88#define DARKNESS_ADJUST(n) (n)
55 89
56#define MAP_EXTEND_X 32 90#define MAP_EXTEND_X 32
57#define MAP_EXTEND_Y 512 91#define MAP_EXTEND_Y 512
58 92
59#define MIN_FONT_HEIGHT 10 93#define MIN_FONT_HEIGHT 10
60 94
61#if 0 95/* mask out modifiers we are not interested in */
62# define PARACHUTE SDL_INIT_NOPARACHUTE 96#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
63#else 97
64# define PARACHUTE 0 98#define KMOD_LRAM 0x10000 // our extension
65#endif 99
100#define TEXID_SPEECH 1
101#define TEXID_NOFACE 2
66 102
67static AV *texture_av; 103static AV *texture_av;
68 104
69static struct 105static struct
70{ 106{
… …
107 av_push (texture_av, (SV *)(size_t)name); 143 av_push (texture_av, (SV *)(size_t)name);
108 glDeleteTextures (1, &name); 144 glDeleteTextures (1, &name);
109} 145}
110 146
111#include "texcache.c" 147#include "texcache.c"
148#include "rendercache.c"
112 149
113#include "pango-font.c" 150#include "pango-font.c"
114#include "pango-fontmap.c" 151#include "pango-fontmap.c"
115#include "pango-render.c" 152#include "pango-render.c"
116 153
154typedef IV DC__Channel;
155typedef SDL_RWops *DC__RW;
117typedef Mix_Chunk *CFPlus__MixChunk; 156typedef Mix_Chunk *DC__MixChunk;
118typedef Mix_Music *CFPlus__MixMusic; 157typedef Mix_Music *DC__MixMusic;
119 158
120typedef PangoFontDescription *CFPlus__Font; 159typedef PangoFontDescription *DC__Font;
121 160
122static int 161static int
123shape_attr_p (PangoLayoutRun *run) 162shape_attr_p (PangoLayoutRun *run)
124{ 163{
125 GSList *attrs = run->item->analysis.extra_attrs; 164 GSList *attrs = run->item->analysis.extra_attrs;
… …
139 178
140typedef struct cf_layout { 179typedef struct cf_layout {
141 PangoLayout *pl; 180 PangoLayout *pl;
142 float r, g, b, a; // default color for rgba mode 181 float r, g, b, a; // default color for rgba mode
143 int base_height; 182 int base_height;
144 CFPlus__Font font; 183 DC__Font font;
184 rc_t *rc;
145} *CFPlus__Layout; 185} *DC__Layout;
146 186
147static CFPlus__Font default_font; 187static DC__Font default_font;
148static PangoContext *opengl_context; 188static PangoContext *opengl_context;
149static PangoFontMap *opengl_fontmap; 189static PangoFontMap *opengl_fontmap;
150 190
151static void 191static void
152substitute_func (FcPattern *pattern, gpointer data) 192substitute_func (FcPattern *pattern, gpointer data)
… …
157#endif 197#endif
158 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 198 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
159} 199}
160 200
161static void 201static void
162layout_update_font (CFPlus__Layout self) 202layout_update_font (DC__Layout self)
163{ 203{
164 /* 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
165 * reasonably well with bitstream vera 205 * reasonably well with dejavu/bistream fonts
166 */ 206 */
167 PangoFontDescription *font = self->font ? self->font : default_font; 207 PangoFontDescription *font = self->font ? self->font : default_font;
168 208
169 pango_font_description_set_absolute_size (font, 209 pango_font_description_set_absolute_size (font,
170 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 210 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
171 211
172 pango_layout_set_font_description (self->pl, font); 212 pango_layout_set_font_description (self->pl, font);
173} 213}
174 214
175static void 215static void
176layout_get_pixel_size (CFPlus__Layout self, int *w, int *h) 216layout_get_pixel_size (DC__Layout self, int *w, int *h)
177{ 217{
178 PangoRectangle rect; 218 PangoRectangle rect;
179 219
180 // get_pixel_* wrongly rounds down 220 // get_pixel_* wrongly rounds down
181 pango_layout_get_extents (self->pl, 0, &rect); 221 pango_layout_get_extents (self->pl, 0, &rect);
… …
192 232
193typedef uint16_t tileid; 233typedef uint16_t tileid;
194typedef uint16_t faceid; 234typedef uint16_t faceid;
195 235
196typedef struct { 236typedef struct {
197 int name; 237 GLuint name;
198 int w, h; 238 int w, h;
199 float s, t; 239 float s, t;
200 uint8_t r, g, b, a; 240 uint8_t r, g, b, a;
201 tileid smoothtile; 241 tileid smoothtile;
202 uint8_t smoothlevel; 242 uint8_t smoothlevel;
243 uint8_t unused; /* set to zero on use */
203} maptex; 244} maptex;
204 245
205typedef struct { 246typedef struct {
206 uint32_t player; 247 uint32_t player;
207 tileid tile[3]; 248 tileid tile[3];
… …
220 int faces; tileid *face2tile; // [faceid] 261 int faces; tileid *face2tile; // [faceid]
221 int texs; maptex *tex; // [tileid] 262 int texs; maptex *tex; // [tileid]
222 263
223 int32_t rows; 264 int32_t rows;
224 maprow *row; 265 maprow *row;
225} *CFPlus__Map; 266} *DC__Map;
226 267
227static char * 268static char *
228prepend (char *ptr, int sze, int inc) 269prepend (char *ptr, int sze, int inc)
229{ 270{
230 char *p; 271 char *p;
… …
268 self->texs *= 2; 309 self->texs *= 2;
269 } 310 }
270} 311}
271 312
272static maprow * 313static maprow *
273map_get_row (CFPlus__Map self, int y) 314map_get_row (DC__Map self, int y)
274{ 315{
275 if (0 > y) 316 if (0 > y)
276 { 317 {
277 int extend = - y + MAP_EXTEND_Y; 318 int extend = - y + MAP_EXTEND_Y;
278 Prepend (maprow, self->row, self->rows, extend); 319 Prepend (maprow, self->row, self->rows, extend);
… …
316 357
317 return row->col + (x - row->c0); 358 return row->col + (x - row->c0);
318} 359}
319 360
320static mapcell * 361static mapcell *
321map_get_cell (CFPlus__Map self, int x, int y) 362map_get_cell (DC__Map self, int x, int y)
322{ 363{
323 return row_get_cell (map_get_row (self, y), x); 364 return row_get_cell (map_get_row (self, y), x);
324} 365}
325 366
326static void 367static void
327map_clear (CFPlus__Map self) 368map_clear (DC__Map self)
328{ 369{
329 int r; 370 int r;
330 371
331 for (r = 0; r < self->rows; r++) 372 for (r = 0; r < self->rows; r++)
332 Safefree (self->row[r].col); 373 Safefree (self->row[r].col);
… …
339 self->oy = 0; 380 self->oy = 0;
340 self->row = 0; 381 self->row = 0;
341 self->rows = 0; 382 self->rows = 0;
342} 383}
343 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
344static void 395static void
345map_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)
346{ 397{
347 int x, y; 398 int x, y;
348 maprow *row; 399 maprow *row;
349 mapcell *cell; 400 mapcell *cell;
350 401
… …
362 if (x >= row->c1) 413 if (x >= row->c1)
363 break; 414 break;
364 415
365 cell = row->col + x - row->c0; 416 cell = row->col + x - row->c0;
366 417
367 cell->darkness = 0; 418 CELL_CLEAR (cell);
368 cell->stat_hp = 0;
369 cell->flags = 0;
370 cell->player = 0;
371 } 419 }
372 } 420 }
373} 421}
374 422
375typedef struct { 423typedef struct {
… …
429 n |= n >> 16; 477 n |= n >> 16;
430 478
431 return n + 1; 479 return n + 1;
432} 480}
433 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
434/* SDL should provide this, really. */ 493/* SDL should provide this, really. */
435#define SDLK_MODIFIER_MIN 300 494#define SDLK_MODIFIER_MIN 300
436#define SDLK_MODIFIER_MAX 314 495#define SDLK_MODIFIER_MAX 314
437 496
438MODULE = 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
439 593
440PROTOTYPES: ENABLE 594PROTOTYPES: ENABLE
441 595
442BOOT: 596BOOT:
443{ 597{
444 HV *stash = gv_stashpv ("CFPlus", 1); 598 HV *stash = gv_stashpv ("DC", 1);
445 static const struct { 599 static const struct {
446 const char *name; 600 const char *name;
447 IV iv; 601 IV iv;
448 } *civ, const_iv[] = { 602 } *civ, const_iv[] = {
449# define const_iv(name) { # name, (IV)name } 603# define const_iv(name) { # name, (IV)name }
… …
471 625
472 const_iv (SDL_APPINPUTFOCUS), 626 const_iv (SDL_APPINPUTFOCUS),
473 const_iv (SDL_APPMOUSEFOCUS), 627 const_iv (SDL_APPMOUSEFOCUS),
474 const_iv (SDL_APPACTIVE), 628 const_iv (SDL_APPACTIVE),
475 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),
476 const_iv (SDLK_KP0), 682 const_iv (SDLK_KP0),
477 const_iv (SDLK_KP1), 683 const_iv (SDLK_KP1),
478 const_iv (SDLK_KP2), 684 const_iv (SDLK_KP2),
479 const_iv (SDLK_KP3), 685 const_iv (SDLK_KP3),
480 const_iv (SDLK_KP4), 686 const_iv (SDLK_KP4),
… …
552 const_iv (KMOD_LMETA), 758 const_iv (KMOD_LMETA),
553 const_iv (KMOD_RMETA), 759 const_iv (KMOD_RMETA),
554 const_iv (KMOD_NUM), 760 const_iv (KMOD_NUM),
555 const_iv (KMOD_CAPS), 761 const_iv (KMOD_CAPS),
556 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)
557# undef const_iv 796# undef const_iv
558 }; 797 };
559 798
560 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; )
561 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 800 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
… …
579 818
580NV floor (NV x) 819NV floor (NV x)
581 820
582NV ceil (NV x) 821NV ceil (NV x)
583 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
584void 833void
585pango_init () 834pango_init ()
586 CODE: 835 CODE:
587{ 836{
588 opengl_fontmap = pango_opengl_font_map_new (); 837 opengl_fontmap = pango_opengl_font_map_new ();
589 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);
590 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
591} 845}
592 846
593char *
594SDL_GetError () 847char *SDL_GetError ()
595 848
596int 849void SDL_braino ()
597SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
598 850
599void 851int SDL_Init (U32 flags)
852
853int SDL_InitSubSystem (U32 flags)
854
855void SDL_QuitSubSystem (U32 flags)
856
600SDL_Quit () 857void SDL_Quit ()
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
601 867
602void 868void
603SDL_ListModes (int rgb, int alpha) 869SDL_ListModes (int rgb, int alpha)
604 PPCODE: 870 PPCODE:
605{ 871{
… …
617 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 883 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
618 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0); 884 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
619 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 885 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
620 886
621 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 887 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
622#if SDL_VERSION_ATLEAST(1,2,10)
623 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
624 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 888 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
625#endif
626 889
627 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 890 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
628 891
629 if (m && m != (SDL_Rect **)-1) 892 if (m && m != (SDL_Rect **)-1)
630 while (*m) 893 while (*m)
631 { 894 {
632 if ((*m)->w >= 640 && (*m)->h >= 480) 895 if ((*m)->w >= 400 && (*m)->h >= 300)
633 { 896 {
634 AV *av = newAV (); 897 AV *av = newAV ();
635 av_push (av, newSViv ((*m)->w)); 898 av_push (av, newSViv ((*m)->w));
636 av_push (av, newSViv ((*m)->h)); 899 av_push (av, newSViv ((*m)->h));
637 av_push (av, newSViv (rgb)); 900 av_push (av, newSViv (rgb));
… …
661 924
662 if (RETVAL) 925 if (RETVAL)
663 { 926 {
664 av_clear (texture_av); 927 av_clear (texture_av);
665 928
666 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 929 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
667#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);
668#include "glfunc.h" 931#include "glfunc.h"
669#undef GL_FUNC 932#undef GL_FUNC
670 } 933 }
671} 934}
… …
678char * 941char *
679SDL_GetKeyName (int sym) 942SDL_GetKeyName (int sym)
680 943
681int 944int
682SDL_GetAppState () 945SDL_GetAppState ()
946
947int
948SDL_GetModState ()
683 949
684void 950void
685poll_events () 951poll_events ()
686 PPCODE: 952 PPCODE:
687{ 953{
… …
697 { 963 {
698 case SDL_KEYDOWN: 964 case SDL_KEYDOWN:
699 case SDL_KEYUP: 965 case SDL_KEYUP:
700 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 966 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
701 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 967 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
702 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);
703 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 */
704 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 970 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
705 break; 971 break;
706 972
707 case SDL_ACTIVEEVENT: 973 case SDL_ACTIVEEVENT:
708 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 974 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
726 x = ev.motion.x; 992 x = ev.motion.x;
727 y = ev.motion.y; 993 y = ev.motion.y;
728 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 994 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
729 } 995 }
730 996
731 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 997 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
732 hv_store (hv, "state", 5, newSViv (state), 0); 998 hv_store (hv, "state", 5, newSViv (state), 0);
733 hv_store (hv, "x", 1, newSViv (x), 0); 999 hv_store (hv, "x", 1, newSViv (x), 0);
734 hv_store (hv, "y", 1, newSViv (y), 0); 1000 hv_store (hv, "y", 1, newSViv (y), 0);
735 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1001 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
736 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1002 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
737 } 1003 }
738 break; 1004 break;
739 1005
740 case SDL_MOUSEBUTTONDOWN: 1006 case SDL_MOUSEBUTTONDOWN:
741 case SDL_MOUSEBUTTONUP: 1007 case SDL_MOUSEBUTTONUP:
742 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1008 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
743 1009
744 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 1010 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
745 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 1011 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
746 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 1012 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
747 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 1013 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
… …
752 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 1018 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
753 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 1019 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
754 break; 1020 break;
755 } 1021 }
756 1022
757 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))));
758 } 1024 }
759} 1025}
760 1026
761int 1027int
762Mix_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)
763 POSTCALL: 1029 POSTCALL:
764 Mix_HookMusicFinished (music_finished); 1030 Mix_HookMusicFinished (music_finished);
765 Mix_ChannelFinished (channel_finished); 1031 Mix_ChannelFinished (channel_finished);
766 1032
767void 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
768Mix_CloseAudio () 1050Mix_CloseAudio ()
769 1051
770int 1052int
771Mix_AllocateChannels (int numchans = -1) 1053Mix_AllocateChannels (int numchans = -1)
1054
1055const char *
1056Mix_GetError ()
772 1057
773void 1058void
774lowdelay (int fd, int val = 1) 1059lowdelay (int fd, int val = 1)
775 CODE: 1060 CODE:
776 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val)); 1061 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
… …
802 } 1087 }
803 } 1088 }
804#endif 1089#endif
805} 1090}
806 1091
807void 1092int
808add_font (char *file) 1093add_font (char *file)
809 CODE: 1094 CODE:
810 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1095 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1096 OUTPUT:
1097 RETVAL
811 1098
812void 1099void
813load_image_inline (SV *image_) 1100load_image_inline (SV *image_)
814 ALIAS: 1101 ALIAS:
815 load_image_file = 1 1102 load_image_file = 1
… …
818 STRLEN image_len; 1105 STRLEN image_len;
819 char *image = (char *)SvPVbyte (image_, image_len); 1106 char *image = (char *)SvPVbyte (image_, image_len);
820 SDL_Surface *surface, *surface2; 1107 SDL_Surface *surface, *surface2;
821 SDL_PixelFormat fmt; 1108 SDL_PixelFormat fmt;
822 SDL_RWops *rw = ix 1109 SDL_RWops *rw = ix
823 ? SDL_RWFromFile (image, "r") 1110 ? SDL_RWFromFile (image, "rb")
824 : SDL_RWFromConstMem (image, image_len); 1111 : SDL_RWFromConstMem (image, image_len);
825 1112
826 if (!rw) 1113 if (!rw)
827 croak ("load_image: %s", SDL_GetError ()); 1114 croak ("load_image: %s", SDL_GetError ());
828 1115
… …
901void 1188void
902error (char *message) 1189error (char *message)
903 CODE: 1190 CODE:
904 fprintf (stderr, "ERROR: %s\n", message); 1191 fprintf (stderr, "ERROR: %s\n", message);
905#ifdef _WIN32 1192#ifdef _WIN32
906 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR); 1193 MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
907#endif 1194#endif
908 1195
909void 1196void
910fatal (char *message) 1197fatal (char *message)
911 CODE: 1198 CODE:
912 fprintf (stderr, "FATAL: %s\n", message); 1199 fprintf (stderr, "FATAL: %s\n", message);
913#ifdef _WIN32 1200#ifdef _WIN32
914 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 1201 MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
915#endif 1202#endif
916 _exit (1); 1203 _exit (1);
917 1204
918void 1205void
919_exit (int retval = 0) 1206_exit (int retval = 0)
… …
931#if DEBUG 1218#if DEBUG
932 VALGRIND_DO_LEAK_CHECK; 1219 VALGRIND_DO_LEAK_CHECK;
933#endif 1220#endif
934} 1221}
935 1222
936MODULE = CFPlus PACKAGE = CFPlus::Font 1223int
1224SvREFCNT (SV *sv)
1225 CODE:
1226 RETVAL = SvREFCNT (sv);
1227 OUTPUT:
1228 RETVAL
937 1229
938CFPlus::Font 1230MODULE = Deliantra::Client PACKAGE = DC::Font
1231
1232PROTOTYPES: DISABLE
1233
1234DC::Font
939new_from_file (SV *class, char *path, int id = 0) 1235new_from_file (SV *class, char *path, int id = 0)
940 CODE: 1236 CODE:
941{ 1237{
942 int count; 1238 int count;
943 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1239 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
… …
946} 1242}
947 OUTPUT: 1243 OUTPUT:
948 RETVAL 1244 RETVAL
949 1245
950void 1246void
951DESTROY (CFPlus::Font self) 1247DESTROY (DC::Font self)
952 CODE: 1248 CODE:
953 pango_font_description_free (self); 1249 pango_font_description_free (self);
954 1250
955void 1251void
956make_default (CFPlus::Font self) 1252make_default (DC::Font self)
1253 PROTOTYPE: $
957 CODE: 1254 CODE:
958 default_font = self; 1255 default_font = self;
959 1256
960MODULE = CFPlus PACKAGE = CFPlus::Layout 1257MODULE = Deliantra::Client PACKAGE = DC::Layout
961 1258
1259PROTOTYPES: DISABLE
1260
962void 1261void
963reset_glyph_cache () 1262glyph_cache_backup ()
1263 PROTOTYPE:
964 CODE: 1264 CODE:
1265 tc_backup ();
1266
1267void
1268glyph_cache_restore ()
1269 PROTOTYPE:
1270 CODE:
965 tc_clear (); 1271 tc_restore ();
966 1272
967CFPlus::Layout 1273DC::Layout
968new (SV *class) 1274new (SV *class)
969 CODE: 1275 CODE:
970 New (0, RETVAL, 1, struct cf_layout); 1276 New (0, RETVAL, 1, struct cf_layout);
971 1277
972 RETVAL->pl = pango_layout_new (opengl_context); 1278 RETVAL->pl = pango_layout_new (opengl_context);
… …
974 RETVAL->g = 1.; 1280 RETVAL->g = 1.;
975 RETVAL->b = 1.; 1281 RETVAL->b = 1.;
976 RETVAL->a = 1.; 1282 RETVAL->a = 1.;
977 RETVAL->base_height = MIN_FONT_HEIGHT; 1283 RETVAL->base_height = MIN_FONT_HEIGHT;
978 RETVAL->font = 0; 1284 RETVAL->font = 0;
1285 RETVAL->rc = rc_alloc ();
979 1286
980 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1287 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
981 layout_update_font (RETVAL); 1288 layout_update_font (RETVAL);
982 OUTPUT: 1289 OUTPUT:
983 RETVAL 1290 RETVAL
984 1291
985void 1292void
986DESTROY (CFPlus::Layout self) 1293DESTROY (DC::Layout self)
987 CODE: 1294 CODE:
988 g_object_unref (self->pl); 1295 g_object_unref (self->pl);
1296 rc_free (self->rc);
989 Safefree (self); 1297 Safefree (self);
990 1298
991void 1299void
992set_text (CFPlus::Layout self, SV *text_) 1300set_text (DC::Layout self, SV *text_)
993 CODE: 1301 CODE:
994{ 1302{
995 STRLEN textlen; 1303 STRLEN textlen;
996 char *text = SvPVutf8 (text_, textlen); 1304 char *text = SvPVutf8 (text_, textlen);
997 1305
998 pango_layout_set_text (self->pl, text, textlen); 1306 pango_layout_set_text (self->pl, text, textlen);
999} 1307}
1000 1308
1001void 1309void
1002set_markup (CFPlus::Layout self, SV *text_) 1310set_markup (DC::Layout self, SV *text_)
1003 CODE: 1311 CODE:
1004{ 1312{
1005 STRLEN textlen; 1313 STRLEN textlen;
1006 char *text = SvPVutf8 (text_, textlen); 1314 char *text = SvPVutf8 (text_, textlen);
1007 1315
1008 pango_layout_set_markup (self->pl, text, textlen); 1316 pango_layout_set_markup (self->pl, text, textlen);
1009} 1317}
1010 1318
1011void 1319void
1012set_shapes (CFPlus::Layout self, ...) 1320set_shapes (DC::Layout self, ...)
1013 CODE: 1321 CODE:
1014{ 1322{
1015 PangoAttrList *attrs = 0; 1323 PangoAttrList *attrs = 0;
1016 const char *text = pango_layout_get_text (self->pl); 1324 const char *text = pango_layout_get_text (self->pl);
1017 const char *pos = text; 1325 const char *pos = text;
… …
1052 if (attrs) 1360 if (attrs)
1053 pango_layout_set_attributes (self->pl, attrs); 1361 pango_layout_set_attributes (self->pl, attrs);
1054} 1362}
1055 1363
1056void 1364void
1057get_shapes (CFPlus::Layout self) 1365get_shapes (DC::Layout self)
1058 PPCODE: 1366 PPCODE:
1059{ 1367{
1060 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1368 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1061 1369
1062 do 1370 do
1063 { 1371 {
1064 PangoLayoutRun *run = pango_layout_iter_get_run (iter); 1372 PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
1065 1373
1066 if (run && shape_attr_p (run)) 1374 if (run && shape_attr_p (run))
1067 { 1375 {
1068 PangoRectangle extents; 1376 PangoRectangle extents;
1069 pango_layout_iter_get_run_extents (iter, 0, &extents); 1377 pango_layout_iter_get_run_extents (iter, 0, &extents);
… …
1077 1385
1078 pango_layout_iter_free (iter); 1386 pango_layout_iter_free (iter);
1079} 1387}
1080 1388
1081int 1389int
1082has_wrapped (CFPlus::Layout self) 1390has_wrapped (DC::Layout self)
1083 CODE: 1391 CODE:
1084{ 1392{
1085 int lines = 1; 1393 int lines = 1;
1086 const char *text = pango_layout_get_text (self->pl); 1394 const char *text = pango_layout_get_text (self->pl);
1087 1395
… …
1092} 1400}
1093 OUTPUT: 1401 OUTPUT:
1094 RETVAL 1402 RETVAL
1095 1403
1096SV * 1404SV *
1097get_text (CFPlus::Layout self) 1405get_text (DC::Layout self)
1098 CODE: 1406 CODE:
1099 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1407 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1100 sv_utf8_decode (RETVAL); 1408 sv_utf8_decode (RETVAL);
1101 OUTPUT: 1409 OUTPUT:
1102 RETVAL 1410 RETVAL
1103 1411
1104void 1412void
1105set_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.)
1106 CODE: 1414 CODE:
1107 self->r = r; 1415 self->r = r;
1108 self->g = g; 1416 self->g = g;
1109 self->b = b; 1417 self->b = b;
1110 self->a = a; 1418 self->a = a;
1111 1419
1112void 1420void
1113set_font (CFPlus::Layout self, CFPlus::Font font = 0) 1421set_font (DC::Layout self, DC::Font font = 0)
1114 CODE: 1422 CODE:
1115 if (self->font != font) 1423 if (self->font != font)
1116 { 1424 {
1117 self->font = font; 1425 self->font = font;
1118 layout_update_font (self); 1426 layout_update_font (self);
1119 } 1427 }
1120 1428
1121void 1429void
1122set_height (CFPlus::Layout self, int base_height) 1430set_height (DC::Layout self, int base_height)
1123 CODE: 1431 CODE:
1124 if (self->base_height != base_height) 1432 if (self->base_height != base_height)
1125 { 1433 {
1126 self->base_height = base_height; 1434 self->base_height = base_height;
1127 layout_update_font (self); 1435 layout_update_font (self);
1128 } 1436 }
1129 1437
1130void 1438void
1131set_width (CFPlus::Layout self, int max_width = -1) 1439set_width (DC::Layout self, int max_width = -1)
1132 CODE: 1440 CODE:
1133 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);
1134 1442
1135void 1443void
1136set_indent (CFPlus::Layout self, int indent) 1444set_indent (DC::Layout self, int indent)
1137 CODE: 1445 CODE:
1138 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1446 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1139 1447
1140void 1448void
1141set_spacing (CFPlus::Layout self, int spacing) 1449set_spacing (DC::Layout self, int spacing)
1142 CODE: 1450 CODE:
1143 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1451 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1144 1452
1145void 1453void
1146set_ellipsise (CFPlus::Layout self, int ellipsise) 1454set_ellipsise (DC::Layout self, int ellipsise)
1147 CODE: 1455 CODE:
1148 pango_layout_set_ellipsize (self->pl, 1456 pango_layout_set_ellipsize (self->pl,
1149 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1457 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1150 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1458 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1151 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1459 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1152 : PANGO_ELLIPSIZE_NONE 1460 : PANGO_ELLIPSIZE_NONE
1153 ); 1461 );
1154 1462
1155void 1463void
1156set_single_paragraph_mode (CFPlus::Layout self, int spm) 1464set_single_paragraph_mode (DC::Layout self, int spm)
1157 CODE: 1465 CODE:
1158 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1466 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1159 1467
1160void 1468void
1161size (CFPlus::Layout self) 1469size (DC::Layout self)
1162 PPCODE: 1470 PPCODE:
1163{ 1471{
1164 int w, h; 1472 int w, h;
1165 1473
1166 layout_get_pixel_size (self, &w, &h); 1474 layout_get_pixel_size (self, &w, &h);
… …
1169 PUSHs (sv_2mortal (newSViv (w))); 1477 PUSHs (sv_2mortal (newSViv (w)));
1170 PUSHs (sv_2mortal (newSViv (h))); 1478 PUSHs (sv_2mortal (newSViv (h)));
1171} 1479}
1172 1480
1173int 1481int
1174descent (CFPlus::Layout self) 1482descent (DC::Layout self)
1175 CODE: 1483 CODE:
1176{ 1484{
1177 PangoRectangle rect; 1485 PangoRectangle rect;
1178 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1486 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1179 pango_layout_line_get_pixel_extents (line, 0, &rect); 1487 pango_layout_line_get_pixel_extents (line, 0, &rect);
1180 RETVAL = PANGO_DESCENT (rect); 1488 RETVAL = PANGO_DESCENT (rect);
1181} 1489}
1182 OUTPUT: 1490 OUTPUT:
1183 RETVAL 1491 RETVAL
1184 1492
1185int 1493int
1186xy_to_index (CFPlus::Layout self, int x, int y) 1494xy_to_index (DC::Layout self, int x, int y)
1187 CODE: 1495 CODE:
1188{ 1496{
1189 int index, trailing; 1497 int index, trailing;
1190 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);
1191 RETVAL = index + trailing; 1499 RETVAL = index + trailing;
1192} 1500}
1193 OUTPUT: 1501 OUTPUT:
1194 RETVAL 1502 RETVAL
1195 1503
1196void 1504void
1197cursor_pos (CFPlus::Layout self, int index) 1505cursor_pos (DC::Layout self, int index)
1198 PPCODE: 1506 PPCODE:
1199{ 1507{
1200 PangoRectangle strong_pos; 1508 PangoRectangle pos;
1201 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1509 pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1202 1510
1203 EXTEND (SP, 3); 1511 EXTEND (SP, 3);
1204 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1512 PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1205 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1513 PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1206 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1514 PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1207} 1515}
1208 1516
1209void 1517void
1210index_to_line_x (CFPlus::Layout self, int index, int trailing = 0) 1518index_to_line_x (DC::Layout self, int index, int trailing = 0)
1211 PPCODE: 1519 PPCODE:
1212{ 1520{
1213 int line, x; 1521 int line, x;
1214 1522
1215 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)
1216 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1525 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1217 1526 --line;
1527#endif
1218 EXTEND (SP, 2); 1528 EXTEND (SP, 2);
1219 PUSHs (sv_2mortal (newSViv (line - 1))); 1529 PUSHs (sv_2mortal (newSViv (line)));
1220 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE))); 1530 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1221} 1531}
1222 1532
1223void 1533void
1224line_x_to_index (CFPlus::Layout self, int line, int x) 1534line_x_to_index (DC::Layout self, int line, int x)
1225 PPCODE: 1535 PPCODE:
1226{ 1536{
1227 PangoLayoutLine *lp; 1537 PangoLayoutLine *lp;
1228 int index, trailing; 1538 int index, trailing;
1229 1539
1230 if (line < 0) 1540 if (line < 0)
1231 XSRETURN_EMPTY; 1541 XSRETURN_EMPTY;
1232 1542
1233 if (!(lp = pango_layout_get_line (self->pl, line))) 1543 if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1234 XSRETURN_EMPTY; /* do better */ 1544 XSRETURN_EMPTY; /* do better */
1235 1545
1236 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);
1237 1547
1238 EXTEND (SP, 2); 1548 EXTEND (SP, 2);
… …
1244 PUSHs (sv_2mortal (newSViv (trailing))); 1554 PUSHs (sv_2mortal (newSViv (trailing)));
1245 } 1555 }
1246} 1556}
1247 1557
1248void 1558void
1249render (CFPlus::Layout self, float x, float y, int flags = 0) 1559render (DC::Layout self, float x, float y, int flags = 0)
1250 PPCODE: 1560 CODE:
1561 rc_clear (self->rc);
1251 pango_opengl_render_layout_subpixel ( 1562 pango_opengl_render_layout_subpixel (
1252 self->pl, 1563 self->pl,
1564 self->rc,
1253 x * PANGO_SCALE, y * PANGO_SCALE, 1565 x * PANGO_SCALE, y * PANGO_SCALE,
1254 self->r, self->g, self->b, self->a, 1566 self->r, self->g, self->b, self->a,
1255 flags 1567 flags
1256 ); 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);
1257 1572
1258MODULE = CFPlus PACKAGE = CFPlus::Texture 1573void
1574draw (DC::Layout self)
1575 CODE:
1576{
1577 glEnable (GL_TEXTURE_2D);
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);
1259 1584
1260int minpot (int n) 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
1261 1595
1262void 1596void
1263pad (SV *data_, int ow, int oh, int nw, int nh) 1597pad (SV *data_, int ow, int oh, int nw, int nh)
1264 CODE: 1598 CODE:
1265{ 1599{
… …
1292 HV *hv = (HV *)SvRV (self); 1626 HV *hv = (HV *)SvRV (self);
1293 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1627 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
1294 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1628 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
1295 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1629 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
1296 1630
1631 if (name <= 0)
1632 XSRETURN_EMPTY;
1633
1297 if (items < 5) 1634 if (items < 5)
1298 { 1635 {
1299 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1636 w = SvNV (*hv_fetch (hv, "w", 1, 1));
1300 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1637 h = SvNV (*hv_fetch (hv, "h", 1, 1));
1301 } 1638 }
… …
1328 glDisable (GL_ALPHA_TEST); 1665 glDisable (GL_ALPHA_TEST);
1329 glDisable (GL_BLEND); 1666 glDisable (GL_BLEND);
1330 } 1667 }
1331} 1668}
1332 1669
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);
1679
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
1333IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1791IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1334 CODE: 1792 CODE:
1335{ 1793{
1336 GLint width; 1794 GLint width;
1337 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0); 1795 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
… …
1339 RETVAL = width > 0; 1797 RETVAL = width > 0;
1340} 1798}
1341 OUTPUT: 1799 OUTPUT:
1342 RETVAL 1800 RETVAL
1343 1801
1344MODULE = CFPlus PACKAGE = CFPlus::Map 1802MODULE = Deliantra::Client PACKAGE = DC::Map
1345 1803
1346CFPlus::Map 1804PROTOTYPES: DISABLE
1805
1806DC::Map
1347new (SV *class) 1807new (SV *class)
1348 CODE: 1808 CODE:
1349 New (0, RETVAL, 1, struct map); 1809 New (0, RETVAL, 1, struct map);
1350 RETVAL->x = 0; 1810 RETVAL->x = 0;
1351 RETVAL->y = 0; 1811 RETVAL->y = 0;
… …
1359 RETVAL->row = 0; 1819 RETVAL->row = 0;
1360 OUTPUT: 1820 OUTPUT:
1361 RETVAL 1821 RETVAL
1362 1822
1363void 1823void
1364DESTROY (CFPlus::Map self) 1824DESTROY (DC::Map self)
1365 CODE: 1825 CODE:
1366{ 1826{
1367 map_clear (self); 1827 map_clear (self);
1368 Safefree (self->face2tile); 1828 Safefree (self->face2tile);
1369 Safefree (self->tex); 1829 Safefree (self->tex);
1370 Safefree (self); 1830 Safefree (self);
1371} 1831}
1372 1832
1373void 1833void
1374resize (CFPlus::Map self, int map_width, int map_height) 1834resize (DC::Map self, int map_width, int map_height)
1375 CODE: 1835 CODE:
1376 self->w = map_width; 1836 self->w = map_width;
1377 self->h = map_height; 1837 self->h = map_height;
1378 1838
1379void 1839void
1380clear (CFPlus::Map self) 1840clear (DC::Map self)
1381 CODE: 1841 CODE:
1382 map_clear (self); 1842 map_clear (self);
1383 1843
1384void 1844void
1385set_tileid (CFPlus::Map self, int face, int tile) 1845set_tileid (DC::Map self, int face, int tile)
1386 CODE: 1846 CODE:
1387{ 1847{
1388 need_facenum (self, face); self->face2tile [face] = tile; 1848 need_facenum (self, face); self->face2tile [face] = tile;
1389 need_texid (self, tile); 1849 need_texid (self, tile);
1390} 1850}
1391 1851
1392void 1852void
1393set_smooth (CFPlus::Map self, int face, int smooth, int level) 1853set_smooth (DC::Map self, int face, int smooth, int level)
1394 CODE: 1854 CODE:
1395{ 1855{
1396 tileid texid; 1856 tileid texid;
1397 maptex *tex; 1857 maptex *tex;
1398 1858
… …
1411 tex->smoothtile = self->face2tile [smooth]; 1871 tex->smoothtile = self->face2tile [smooth];
1412 tex->smoothlevel = level; 1872 tex->smoothlevel = level;
1413} 1873}
1414 1874
1415void 1875void
1416set_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)
1417 CODE: 1877 CODE:
1418{ 1878{
1419 need_texid (self, texid); 1879 need_texid (self, texid);
1420 1880
1421 { 1881 {
… …
1440 // use uglier nearest interpolation because linear suffers 1900 // use uglier nearest interpolation because linear suffers
1441 // from transparent color bleeding and ugly wrapping effects. 1901 // from transparent color bleeding and ugly wrapping effects.
1442 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1902 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1443} 1903}
1444 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
1445int 1925int
1446ox (CFPlus::Map self) 1926ox (DC::Map self)
1447 ALIAS: 1927 ALIAS:
1448 oy = 1 1928 oy = 1
1449 x = 2 1929 x = 2
1450 y = 3 1930 y = 3
1451 w = 4 1931 w = 4
… …
1462 } 1942 }
1463 OUTPUT: 1943 OUTPUT:
1464 RETVAL 1944 RETVAL
1465 1945
1466void 1946void
1467scroll (CFPlus::Map self, int dx, int dy) 1947scroll (DC::Map self, int dx, int dy)
1468 CODE: 1948 CODE:
1469{ 1949{
1470 if (dx > 0) 1950 if (dx > 0)
1471 map_blank (self, self->x, self->y, dx, self->h); 1951 map_blank (self, self->x, self->y, dx, self->h);
1472 else if (dx < 0) 1952 else if (dx < 0)
… …
1487 self->rows += MAP_EXTEND_Y; 1967 self->rows += MAP_EXTEND_Y;
1488 self->y += MAP_EXTEND_Y; 1968 self->y += MAP_EXTEND_Y;
1489 } 1969 }
1490} 1970}
1491 1971
1492void 1972SV *
1493map1a_update (CFPlus::Map self, SV *data_, int extmap) 1973map1a_update (DC::Map self, SV *data_, int extmap)
1494 CODE: 1974 CODE:
1495{ 1975{
1496 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1976 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1497 uint8_t *data_end = (uint8_t *)SvEND (data_); 1977 uint8_t *data_end = (uint8_t *)SvEND (data_);
1498 mapcell *cell; 1978 mapcell *cell;
1499 int x, y, flags; 1979 int x, y, z, flags;
1980 AV *missing = newAV ();
1981 RETVAL = newRV_noinc ((SV *)missing);
1500 1982
1501 while (data < data_end - 1) 1983 while (data < data_end - 1)
1502 { 1984 {
1503 flags = (data [0] << 8) + data [1]; data += 2; 1985 flags = (data [0] << 8) + data [1]; data += 2;
1504 1986
… …
1524 uint8_t ext, cmd; 2006 uint8_t ext, cmd;
1525 2007
1526 do 2008 do
1527 { 2009 {
1528 ext = *data++; 2010 ext = *data++;
1529 cmd = ext & 0x3f; 2011 cmd = ext & 0x7f;
1530 2012
1531 if (cmd < 4) 2013 if (cmd < 4)
1532 cell->darkness = 255 - ext * 64 + 1; 2014 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
1533 else if (cmd == 5) // health 2015 else if (cmd == 5) // health
1534 { 2016 {
1535 cell->stat_width = 1; 2017 cell->stat_width = 1;
1536 cell->stat_hp = *data++; 2018 cell->stat_hp = *data++;
1537 } 2019 }
1538 else if (cmd == 6) // monster width 2020 else if (cmd == 6) // monster width
1539 cell->stat_width = *data++ + 1; 2021 cell->stat_width = *data++ + 1;
1540 else if (cmd == 0x47) 2022 else if (cmd == 0x47)
1541 { 2023 {
1542 if (*data == 4) 2024 if (*data == 1) cell->player = data [1];
1543 ; // 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);
1544 2028
1545 data += *data + 1; 2029 data += *data + 1;
1546 } 2030 }
1547 else if (cmd == 8) // cell flags 2031 else if (cmd == 8) // cell flags
1548 cell->flags = *data++; 2032 cell->flags = *data++;
… …
1555 } 2039 }
1556 else 2040 else
1557 cell->darkness = *data++ + 1; 2041 cell->darkness = *data++ + 1;
1558 } 2042 }
1559 2043
2044 for (z = 0; z <= 2; ++z)
1560 if (flags & 4) 2045 if (flags & (4 >> z))
1561 { 2046 {
1562 faceid face = (data [0] << 8) + data [1]; data += 2; 2047 faceid face = (data [0] << 8) + data [1]; data += 2;
1563 need_facenum (self, face); 2048 need_facenum (self, face);
1564 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 }
1565 } 2066 }
1566
1567 if (flags & 2)
1568 {
1569 faceid face = (data [0] << 8) + data [1]; data += 2;
1570 need_facenum (self, face);
1571 cell->tile [1] = self->face2tile [face];
1572 }
1573
1574 if (flags & 1)
1575 {
1576 faceid face = (data [0] << 8) + data [1]; data += 2;
1577 need_facenum (self, face);
1578 cell->tile [2] = self->face2tile [face];
1579 }
1580 } 2067 }
1581 else 2068 else
1582 cell->darkness = 0; 2069 CELL_CLEAR (cell);
1583 } 2070 }
1584} 2071}
2072 OUTPUT:
2073 RETVAL
1585 2074
1586SV * 2075SV *
1587mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 2076mapmap (DC::Map self, int x0, int y0, int w, int h)
1588 CODE: 2077 CODE:
1589{ 2078{
1590 int x1, x; 2079 int x1, x;
1591 int y1, y; 2080 int y1, y;
1592 int z; 2081 int z;
… …
1637} 2126}
1638 OUTPUT: 2127 OUTPUT:
1639 RETVAL 2128 RETVAL
1640 2129
1641void 2130void
1642draw (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)
1643 CODE: 2132 CODE:
1644{ 2133{
2134 int x, y, z;
2135
1645 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ()); 2136 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1646 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
1647 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)
1648 smooth_key skey; 2139 smooth_key skey;
1649 int x, y, z; 2140 int pl_x, pl_y;
1650 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;
1651 2146
2147 pl_tex.name = 0;
2148
1652 // thats current max. sorry. 2149 // that's current max. sorry.
1653 if (sw > 255) sw = 255; 2150 if (sw > 255) sw = 255;
1654 if (sh > 255) sh = 255; 2151 if (sh > 255) sh = 255;
1655 2152
1656 // clear key, in case of extra padding 2153 // clear key, in case of extra padding
1657 memset (&skey, 0, sizeof (skey)); 2154 memset (&skey, 0, sizeof (skey));
1658 2155
1659 glColor4ub (255, 255, 255, 255); 2156 memset (&key, 0, sizeof (key));
1660 2157 key.r = 255;
1661 glEnable (GL_BLEND); 2158 key.g = 255;
1662 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2159 key.b = 255;
1663 glEnable (GL_TEXTURE_2D); 2160 key.a = 255;
1664 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2161 key.mode = GL_QUADS;
1665 2162 key.format = GL_T2F_V3F;
1666 glBegin (GL_QUADS);
1667
1668 last_name = 0;
1669 2163
1670 mx += self->x; 2164 mx += self->x;
1671 my += self->y; 2165 my += self->y;
1672 2166
1673 // first pass: determine smooth_max 2167 // first pass: determine smooth_max
… …
1690 MAX (self->tex [cell->tile [1]].smoothlevel, 2184 MAX (self->tex [cell->tile [1]].smoothlevel,
1691 self->tex [cell->tile [2]].smoothlevel)); 2185 self->tex [cell->tile [2]].smoothlevel));
1692 } 2186 }
1693 } 2187 }
1694 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
1695 for (z = 0; z <= 2; z++) 2193 for (z = 0; z <= 2; z++)
1696 { 2194 {
1697 memset (smooth_level, 0, sizeof (smooth_level)); 2195 memset (smooth_level, 0, sizeof (smooth_level));
2196 key.texname = -1;
1698 2197
1699 for (y = 0; y < sh; y++) 2198 for (y = 0; y < sh; y++)
1700 if (0 <= y + my && y + my < self->rows) 2199 if (0 <= y + my && y + my < self->rows)
1701 { 2200 {
1702 maprow *row = self->row + (y + my); 2201 maprow *row = self->row + (y + my);
… …
1708 tileid tile = cell->tile [z]; 2207 tileid tile = cell->tile [z];
1709 2208
1710 if (tile) 2209 if (tile)
1711 { 2210 {
1712 maptex tex = self->tex [tile]; 2211 maptex tex = self->tex [tile];
1713 int px = (x + 1) * T - tex.w; 2212 int px, py;
1714 int py = (y + 1) * T - tex.h;
1715 2213
1716 // suppressing texture state switches here
1717 // is only moderately effective, but worth the extra effort
1718 if (last_name != tex.name) 2214 if (key.texname != tex.name)
1719 { 2215 {
2216 self->tex [tile].unused = 0;
2217
1720 if (!tex.name) 2218 if (!tex.name)
1721 tex = self->tex [2]; /* missing, replace by noface */ 2219 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1722 2220
1723 glEnd (); 2221 key.texname = tex.name;
1724 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2222 arr = rc_array (rc, &key);
1725 glBegin (GL_QUADS);
1726 } 2223 }
1727 2224
1728 glTexCoord2f (0 , 0 ); glVertex2f (px , py ); 2225 px = (x + 1) * T - tex.w;
1729 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h); 2226 py = (y + 1) * T - tex.h;
1730 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1731 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1732 2227
1733 if (cell->flags && z == 2) 2228 if (expect_false (cell->player == player) && expect_false (z == 2))
1734 { 2229 {
1735 if (cell->flags & 1) 2230 pl_x = px;
2231 pl_y = py;
2232 pl_tex = tex;
1736 { 2233 continue;
1737 maptex tex = self->tex [1];
1738 int px = x * T + T * 2 / 32;
1739 int py = y * T - T * 6 / 32;
1740
1741 glEnd ();
1742 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1743 glBegin (GL_QUADS);
1744
1745 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1746 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1747 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1748 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1749 }
1750 } 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);
1751 2240
1752 // update smooth hash 2241 // update smooth hash
1753 if (tex.smoothtile) 2242 if (tex.smoothtile)
1754 { 2243 {
1755 skey.tile = tex.smoothtile; 2244 skey.tile = tex.smoothtile;
… …
1786 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);
1787 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);
1788 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);
1789 } 2278 }
1790 } 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 }
1791 } 2301 }
1792 } 2302 }
2303
2304 rc_draw (rc);
2305 rc_clear (rc);
1793 2306
1794 // go through all smoothlevels, lowest to highest, then draw. 2307 // go through all smoothlevels, lowest to highest, then draw.
1795 // this is basically counting sort 2308 // this is basically counting sort
1796 { 2309 {
1797 int w, b; 2310 int w, b;
1798 2311
2312 glEnable (GL_TEXTURE_2D);
2313 glBegin (GL_QUADS);
1799 for (w = 0; w < 256 / 32; ++w) 2314 for (w = 0; w < 256 / 32; ++w)
1800 { 2315 {
1801 uint32_t smask = smooth_level [w]; 2316 uint32_t smask = smooth_level [w];
1802 if (smask) 2317 if (smask)
1803 for (b = 0; b < 32; ++b) 2318 for (b = 0; b < 32; ++b)
… …
1822 int border = bits & 15; 2337 int border = bits & 15;
1823 int corner = (bits >> 8) & ~(bits >> 4) & 15; 2338 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1824 float dx = tex.s * .0625f; // 16 images/row 2339 float dx = tex.s * .0625f; // 16 images/row
1825 float dy = tex.t * .5f ; // 2 images/column 2340 float dy = tex.t * .5f ; // 2 images/column
1826 2341
1827 // this time naively avoiding texture state changes
1828 // save gobs of state changes.
1829 if (last_name != tex.name) 2342 if (tex.name)
1830 { 2343 {
2344 // this time avoiding texture state changes
2345 // save gobs of state changes.
1831 if (!tex.name) 2346 if (key.texname != tex.name)
1832 continue; // smoothing not yet available 2347 {
2348 self->tex [skey->tile].unused = 0;
1833 2349
1834 glEnd (); 2350 glEnd ();
1835 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2351 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1836 glBegin (GL_QUADS); 2352 glBegin (GL_QUADS);
1837 } 2353 }
1838 2354
1839 if (border) 2355 if (border)
1840 { 2356 {
1841 float ox = border * dx; 2357 float ox = border * dx;
1842 2358
1843 glTexCoord2f (ox , 0.f ); glVertex2f (px , py ); 2359 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1844 glTexCoord2f (ox , dy ); glVertex2f (px , py + T); 2360 glTexCoord2f (ox , dy ); glVertex2i (px , py + T);
1845 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T); 2361 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);
1846 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py ); 2362 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );
1847 } 2363 }
1848 2364
1849 if (corner) 2365 if (corner)
1850 { 2366 {
1851 float ox = corner * dx; 2367 float ox = corner * dx;
1852 2368
1853 glTexCoord2f (ox , dy ); glVertex2f (px , py ); 2369 glTexCoord2f (ox , dy ); glVertex2i (px , py );
1854 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T); 2370 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);
1855 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T); 2371 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);
1856 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py ); 2372 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );
2373 }
1857 } 2374 }
1858 } 2375 }
1859 } 2376 }
1860 } 2377 }
1861 } 2378 }
2379
2380 glEnd ();
2381 glDisable (GL_TEXTURE_2D);
2382 key.texname = -1;
1862 } 2383 }
1863 2384
1864 hv_clear (smooth); 2385 hv_clear (smooth);
1865 } 2386 }
1866 2387
1867 glEnd (); 2388 if (pl_tex.name)
2389 {
2390 maptex tex = pl_tex;
2391 int px = pl_x + sdx;
2392 int py = pl_y + sdy;
1868 2393
1869 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
1870 glDisable (GL_BLEND); 2408 glDisable (GL_BLEND);
2409 rc_free (rc);
2410 rc_free (rc_ov);
1871 2411
1872 // top layer: overlays such as the health bar 2412 // top layer: overlays such as the health bar
1873 for (y = 0; y < sh; y++) 2413 for (y = 0; y < sh; y++)
1874 if (0 <= y + my && y + my < self->rows) 2414 if (0 <= y + my && y + my < self->rows)
1875 { 2415 {
… …
1880 { 2420 {
1881 mapcell *cell = row->col + (x + mx - row->c0); 2421 mapcell *cell = row->col + (x + mx - row->c0);
1882 2422
1883 int px = x * T; 2423 int px = x * T;
1884 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 }
1885 2431
1886 if (cell->stat_hp) 2432 if (cell->stat_hp)
1887 { 2433 {
1888 int width = cell->stat_width * T; 2434 int width = cell->stat_width * T;
1889 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2435 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
… …
1900 } 2446 }
1901 } 2447 }
1902} 2448}
1903 2449
1904void 2450void
1905draw_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)
1906 CODE: 2452 CODE:
1907{ 2453{
1908 static float color[16][3] = { 2454 static float color[16][3] = {
1909 { 0.00F, 0.00F, 0.00F }, 2455 { 0.00f, 0.00f, 0.00f },
1910 { 1.00F, 1.00F, 1.00F }, 2456 { 1.00f, 1.00f, 1.00f },
1911 { 0.00F, 0.00F, 0.55F }, 2457 { 0.00f, 0.00f, 0.55f },
1912 { 1.00F, 0.00F, 0.00F }, 2458 { 1.00f, 0.00f, 0.00f },
1913 2459
1914 { 1.00F, 0.54F, 0.00F }, 2460 { 1.00f, 0.54f, 0.00f },
1915 { 0.11F, 0.56F, 1.00F }, 2461 { 0.11f, 0.56f, 1.00f },
1916 { 0.93F, 0.46F, 0.00F }, 2462 { 0.93f, 0.46f, 0.00f },
1917 { 0.18F, 0.54F, 0.34F }, 2463 { 0.18f, 0.54f, 0.34f },
1918 2464
1919 { 0.56F, 0.73F, 0.56F }, 2465 { 0.56f, 0.73f, 0.56f },
1920 { 0.80F, 0.80F, 0.80F }, 2466 { 0.80f, 0.80f, 0.80f },
1921 { 0.55F, 0.41F, 0.13F }, 2467 { 0.55f, 0.41f, 0.13f },
1922 { 0.99F, 0.77F, 0.26F }, 2468 { 0.99f, 0.77f, 0.26f },
1923 2469
1924 { 0.74F, 0.65F, 0.41F }, 2470 { 0.74f, 0.65f, 0.41f },
1925 2471
1926 { 0.00F, 1.00F, 1.00F }, 2472 { 0.00f, 1.00f, 1.00f },
1927 { 1.00F, 0.00F, 1.00F }, 2473 { 1.00f, 0.00f, 1.00f },
1928 { 1.00F, 1.00F, 0.00F }, 2474 { 1.00f, 1.00f, 0.00f },
1929 }; 2475 };
1930 2476
1931 int x, y; 2477 int x, y;
1932 2478
1933 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 */
1934 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2486 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1935 glEnable (GL_BLEND); 2487 glEnable (GL_BLEND);
1936 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2488 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1937 glBegin (GL_QUADS); 2489 glBegin (GL_QUADS);
1938 2490
1939 for (y = 0; y < h; y++) 2491 for (y = 0; y < h; y++)
… …
1943 2495
1944 if (m) 2496 if (m)
1945 { 2497 {
1946 float *c = color [m & 15]; 2498 float *c = color [m & 15];
1947 2499
1948 float tx1 = m & 0x40 ? 0.5 : 0.; 2500 float tx1 = m & 0x40 ? 0.5f : 0.f;
1949 float tx2 = tx1 + 0.5; 2501 float tx2 = tx1 + 0.5f;
1950 2502
1951 glColor4f (c[0], c[1], c[2], 0.75); 2503 glColor4f (c[0], c[1], c[2], 1);
1952 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2504 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
1953 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2505 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
1954 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2506 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
1955 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2507 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
1956 } 2508 }
… …
1960 glDisable (GL_BLEND); 2512 glDisable (GL_BLEND);
1961 glDisable (GL_TEXTURE_2D); 2513 glDisable (GL_TEXTURE_2D);
1962} 2514}
1963 2515
1964void 2516void
1965fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh, int smoothing, const char *matrix) 2517fow_texture (DC::Map self, int mx, int my, int sw, int sh)
1966 PPCODE: 2518 PPCODE:
1967{ 2519{
1968 int x, y; 2520 int x, y;
1969 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);
1970 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2526 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
1971 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2527 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1972 2528
1973 memset (darkness, 255, sw4 * sh);
1974 SvPOK_only (darkness_sv); 2529 SvPOK_only (darkness3_sv);
1975 SvCUR_set (darkness_sv, sw4 * sh); 2530 SvCUR_set (darkness3_sv, sw3 * sh3);
1976 2531
1977 mx += self->x; 2532 mx += self->x - 1;
1978 my += self->y; 2533 my += self->y - 1;
1979 2534
1980 for (y = 0; y < sh; y++) 2535 for (y = 0; y < sh1; y++)
1981 if (0 <= y + my && y + my < self->rows) 2536 if (0 <= y + my && y + my < self->rows)
1982 { 2537 {
1983 maprow *row = self->row + (y + my); 2538 maprow *row = self->row + (y + my);
1984 2539
1985 for (x = 0; x < sw; x++) 2540 for (x = 0; x < sw1; x++)
1986 if (row->c0 <= x + mx && x + mx < row->c1) 2541 if (row->c0 <= x + mx && x + mx < row->c1)
1987 { 2542 {
1988 mapcell *cell = row->col + (x + mx - row->c0); 2543 mapcell *cell = row->col + (x + mx - row->c0);
1989 2544
1990 darkness[y * sw4 + x] = cell->darkness 2545 darkness1 [y * sw1 + x] = cell->darkness
1991 ? 255 - (cell->darkness - 1) 2546 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
1992 : 255 - FOW_DARKNESS; 2547 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
1993 } 2548 }
1994 } 2549 }
1995 2550
1996 if (smoothing)
1997 {
1998 SV *darkness2_sv = sv_2mortal (newSV (sw4 * sh));
1999 uint8_t *darkness2 = (uint8_t *)SvPVX (darkness2_sv);
2000
2001 SvPOK_only (darkness2_sv);
2002 SvCUR_set (darkness2_sv, sw4 * sh);
2003
2004 for (y = 0; y < sh; ++y) 2551 for (y = 0; y < sh; ++y)
2005 for (x = 0; x < sw4; ++x) 2552 for (x = 0; x < sw; ++x)
2006 { 2553 {
2007 float *f = (float *)matrix; 2554 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2008 int dx, dy; 2555 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2009 float sum = 0.f; 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];
2010 2563
2011 for (dy = -1; dy <= 1; ++dy) 2564 uint8_t r11 = (d11 + d21 + d12) / 3;
2012 for (dx = -1; dx <= 1; ++dx) 2565 uint8_t r21 = d21;
2013 { 2566 uint8_t r31 = (d21 + d31 + d32) / 3;
2014 unsigned int x2 = x + dx;
2015 unsigned int y2 = y + dy;
2016 2567
2017 sum += (x2 < sw && y2 < sh ? darkness [y2 * sw4 + x2] : 255) * *f++; 2568 uint8_t r12 = d12;
2018 } 2569 uint8_t r22 = d22;
2570 uint8_t r32 = d32;
2019 2571
2020 darkness2 [y * sw4 + x] = sum > 255. ? 255. : sum; 2572 uint8_t r13 = (d13 + d23 + d12) / 3;
2021 } 2573 uint8_t r23 = d23;
2574 uint8_t r33 = (d23 + d33 + d32) / 3;
2022 2575
2023 darkness_sv = darkness2_sv; 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);
2024 } 2585 }
2586
2587 free (darkness1);
2025 2588
2026 EXTEND (SP, 3); 2589 EXTEND (SP, 3);
2027 PUSHs (sv_2mortal (newSViv (sw4))); 2590 PUSHs (sv_2mortal (newSViv (sw3)));
2028 PUSHs (sv_2mortal (newSViv (sh))); 2591 PUSHs (sv_2mortal (newSViv (sh3)));
2029 PUSHs (darkness_sv); 2592 PUSHs (darkness3_sv);
2030} 2593}
2031 2594
2032SV * 2595SV *
2033get_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)
2034 CODE: 2597 CODE:
2035{ 2598{
2036 int x, y, x1, y1; 2599 int x, y, x1, y1;
2037 SV *data_sv = newSV (w * h * 7 + 5); 2600 SV *data_sv = newSV (w * h * 7 + 5);
2038 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2601 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
2095 else 2658 else
2096 *data++ = 0; 2659 *data++ = 0;
2097 } 2660 }
2098 } 2661 }
2099 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 {
2100 SvPOK_only (data_sv); 2666 SvPOK_only (data_sv);
2101 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2667 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2668 }
2669
2102 RETVAL = data_sv; 2670 RETVAL = data_sv;
2103} 2671}
2104 OUTPUT: 2672 OUTPUT:
2105 RETVAL 2673 RETVAL
2106 2674
2107void 2675void
2108set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2676set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2109 PPCODE: 2677 PPCODE:
2110{ 2678{
2111 int x, y, z; 2679 int x, y, z;
2112 int w, h; 2680 int w, h;
2113 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;
2114 2692
2115 if (*data++ != 0) 2693 if (*data++ != 0)
2116 return; /* version mismatch */ 2694 XSRETURN_EMPTY; /* version mismatch */
2117 2695
2118 w = *data++ << 8; w |= *data++; 2696 w = *data++ << 8; w |= *data++;
2119 h = *data++ << 8; h |= *data++; 2697 h = *data++ << 8; h |= *data++;
2120 2698
2121 // 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
… …
2133 { 2711 {
2134 maprow *row = map_get_row (self, y); 2712 maprow *row = map_get_row (self, y);
2135 2713
2136 for (x = x0; x < x1; x++) 2714 for (x = x0; x < x1; x++)
2137 { 2715 {
2716 uint8_t flags;
2717
2718 if (data + 7 >= end)
2719 XSRETURN_EMPTY;
2720
2138 uint8_t flags = *data++; 2721 flags = *data++;
2139 2722
2140 if (flags) 2723 if (flags)
2141 { 2724 {
2142 mapcell *cell = row_get_cell (row, x); 2725 mapcell *cell = row_get_cell (row, x);
2143 tileid tile[3] = { 0, 0, 0 }; 2726 tileid tile[3] = { 0, 0, 0 };
… …
2146 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2729 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2147 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2730 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2148 2731
2149 if (cell->darkness == 0) 2732 if (cell->darkness == 0)
2150 { 2733 {
2151 cell->darkness = 0; 2734 /*cell->darkness = 0;*/
2735 EXTEND (SP, 3);
2152 2736
2153 for (z = 0; z <= 2; z++) 2737 for (z = 0; z <= 2; z++)
2154 { 2738 {
2155 tileid t = tile [z]; 2739 tileid t = tile [z];
2156 2740
2157 if (t >= self->texs || (t && !self->tex [t].name)) 2741 if (t >= self->texs || (t && !self->tex [t].name))
2158 { 2742 {
2159 XPUSHs (sv_2mortal (newSViv (t))); 2743 PUSHs (sv_2mortal (newSViv (t)));
2160 need_texid (self, t); 2744 need_texid (self, t);
2161 } 2745 }
2162 2746
2163 cell->tile [z] = t; 2747 cell->tile [z] = t;
2164 } 2748 }
… …
2166 } 2750 }
2167 } 2751 }
2168 } 2752 }
2169} 2753}
2170 2754
2171MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2755MODULE = Deliantra::Client PACKAGE = DC::RW
2172 2756
2173CFPlus::MixChunk 2757DC::RW
2174new_from_file (SV *class, char *path) 2758new (SV *class, SV *data_sv)
2175 CODE: 2759 CODE:
2176 RETVAL = Mix_LoadWAV (path); 2760{
2761 STRLEN datalen;
2762 char *data = SvPVbyte (data_sv, datalen);
2763
2764 RETVAL = SDL_RWFromConstMem (data, datalen);
2765}
2177 OUTPUT: 2766 OUTPUT:
2178 RETVAL 2767 RETVAL
2179 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 : '('
2180void 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
2181DESTROY (CFPlus::MixChunk self) 2878DESTROY (DC::MixChunk self)
2182 CODE: 2879 CODE:
2183 Mix_FreeChunk (self); 2880 Mix_FreeChunk (self);
2184 2881
2185int 2882int
2186volume (CFPlus::MixChunk self, int volume = -1) 2883volume (DC::MixChunk self, int volume = -1)
2187 CODE: 2884 CODE:
2885 if (items > 1)
2886 volume = CLAMP (volume, 0, 128);
2188 RETVAL = Mix_VolumeChunk (self, volume); 2887 RETVAL = Mix_VolumeChunk (self, volume);
2189 OUTPUT: 2888 OUTPUT:
2190 RETVAL 2889 RETVAL
2191 2890
2192int 2891DC::Channel
2193play (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)
2194 CODE: 2893 CODE:
2894{
2195 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}
2196 OUTPUT: 2906 OUTPUT:
2197 RETVAL 2907 RETVAL
2198 2908
2199MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2909MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2200 2910
2201int 2911int
2202volume (int volume = -1) 2912volume (int volume = -1)
2913 PROTOTYPE: ;$
2203 CODE: 2914 CODE:
2915 if (items > 0)
2916 volume = CLAMP (volume, 0, 128);
2204 RETVAL = Mix_VolumeMusic (volume); 2917 RETVAL = Mix_VolumeMusic (volume);
2205 OUTPUT: 2918 OUTPUT:
2206 RETVAL 2919 RETVAL
2207 2920
2208int 2921void
2209fade_out (int ms) 2922fade_out (int ms)
2210 CODE: 2923 CODE:
2211 RETVAL = Mix_FadeOutMusic (ms); 2924 Mix_FadeOutMusic (ms);
2925
2926void
2927halt ()
2928 CODE:
2929 Mix_HaltMusic ();
2930
2931DC::MixMusic
2932new (SV *class, DC::RW rwops)
2933 CODE:
2934 RETVAL = Mix_LoadMUS_RW (rwops);
2212 OUTPUT: 2935 OUTPUT:
2213 RETVAL 2936 RETVAL
2214 2937
2215CFPlus::MixMusic
2216new_from_file (SV *class, char *path)
2217 CODE:
2218 RETVAL = Mix_LoadMUS (path);
2219 OUTPUT:
2220 RETVAL
2221
2222void 2938void
2223DESTROY (CFPlus::MixMusic self) 2939DESTROY (DC::MixMusic self)
2224 CODE: 2940 CODE:
2225 Mix_FreeMusic (self); 2941 Mix_FreeMusic (self);
2226 2942
2227int 2943int
2228play (CFPlus::MixMusic self, int loops = -1) 2944play (DC::MixMusic self, int loops = -1)
2229 CODE: 2945 CODE:
2230 RETVAL = Mix_PlayMusic (self, loops); 2946 RETVAL = Mix_PlayMusic (self, loops);
2231 OUTPUT: 2947 OUTPUT:
2232 RETVAL 2948 RETVAL
2233 2949
2234int 2950void
2235fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position) 2951fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2236 CODE: 2952 CODE:
2237 RETVAL = Mix_FadeInMusicPos (self, loops, ms, position); 2953 Mix_FadeInMusicPos (self, loops, ms, position);
2238 OUTPUT:
2239 RETVAL
2240 2954
2241MODULE = CFPlus PACKAGE = CFPlus::OpenGL 2955MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2956
2957PROTOTYPES: ENABLE
2242 2958
2243BOOT: 2959BOOT:
2244{ 2960{
2245 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 2961 HV *stash = gv_stashpv ("DC::OpenGL", 1);
2246 static const struct { 2962 static const struct {
2247 const char *name; 2963 const char *name;
2248 IV iv; 2964 IV iv;
2249 } *civ, const_iv[] = { 2965 } *civ, const_iv[] = {
2250# define const_iv(name) { # name, (IV)name } 2966# define const_iv(name) { # name, (IV)name }
2251 const_iv (GL_VENDOR), 2967 const_iv (GL_VENDOR),
2252 const_iv (GL_VERSION), 2968 const_iv (GL_VERSION),
2253 const_iv (GL_EXTENSIONS), 2969 const_iv (GL_EXTENSIONS),
2970 const_iv (GL_MAX_TEXTURE_UNITS),
2254 const_iv (GL_COLOR_MATERIAL), 2971 const_iv (GL_COLOR_MATERIAL),
2255 const_iv (GL_SMOOTH), 2972 const_iv (GL_SMOOTH),
2256 const_iv (GL_FLAT), 2973 const_iv (GL_FLAT),
2257 const_iv (GL_DITHER), 2974 const_iv (GL_DITHER),
2258 const_iv (GL_BLEND), 2975 const_iv (GL_BLEND),
… …
2262 const_iv (GL_ALPHA_TEST), 2979 const_iv (GL_ALPHA_TEST),
2263 const_iv (GL_NORMALIZE), 2980 const_iv (GL_NORMALIZE),
2264 const_iv (GL_RESCALE_NORMAL), 2981 const_iv (GL_RESCALE_NORMAL),
2265 const_iv (GL_FRONT), 2982 const_iv (GL_FRONT),
2266 const_iv (GL_BACK), 2983 const_iv (GL_BACK),
2984 const_iv (GL_AUX0),
2267 const_iv (GL_AND), 2985 const_iv (GL_AND),
2268 const_iv (GL_ONE), 2986 const_iv (GL_ONE),
2269 const_iv (GL_ZERO), 2987 const_iv (GL_ZERO),
2270 const_iv (GL_SRC_ALPHA), 2988 const_iv (GL_SRC_ALPHA),
2271 const_iv (GL_DST_ALPHA), 2989 const_iv (GL_DST_ALPHA),
2272 const_iv (GL_ONE_MINUS_SRC_ALPHA), 2990 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2273 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),
2274 const_iv (GL_SRC_ALPHA_SATURATE), 2996 const_iv (GL_SRC_ALPHA_SATURATE),
2275 const_iv (GL_RGB), 2997 const_iv (GL_RGB),
2276 const_iv (GL_RGBA), 2998 const_iv (GL_RGBA),
2277 const_iv (GL_RGBA4), 2999 const_iv (GL_RGBA4),
2278 const_iv (GL_RGBA8), 3000 const_iv (GL_RGBA8),
… …
2284 const_iv (GL_INTENSITY), 3006 const_iv (GL_INTENSITY),
2285 const_iv (GL_LUMINANCE), 3007 const_iv (GL_LUMINANCE),
2286 const_iv (GL_LUMINANCE_ALPHA), 3008 const_iv (GL_LUMINANCE_ALPHA),
2287 const_iv (GL_FLOAT), 3009 const_iv (GL_FLOAT),
2288 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),
2289 const_iv (GL_COMPILE), 3017 const_iv (GL_COMPILE),
2290 const_iv (GL_PROXY_TEXTURE_1D), 3018 const_iv (GL_PROXY_TEXTURE_1D),
2291 const_iv (GL_PROXY_TEXTURE_2D), 3019 const_iv (GL_PROXY_TEXTURE_2D),
2292 const_iv (GL_TEXTURE_1D), 3020 const_iv (GL_TEXTURE_1D),
2293 const_iv (GL_TEXTURE_2D), 3021 const_iv (GL_TEXTURE_2D),
… …
2317 const_iv (GL_COLOR_LOGIC_OP), 3045 const_iv (GL_COLOR_LOGIC_OP),
2318 const_iv (GL_SEPARABLE_2D), 3046 const_iv (GL_SEPARABLE_2D),
2319 const_iv (GL_CONVOLUTION_2D), 3047 const_iv (GL_CONVOLUTION_2D),
2320 const_iv (GL_CONVOLUTION_BORDER_MODE), 3048 const_iv (GL_CONVOLUTION_BORDER_MODE),
2321 const_iv (GL_CONSTANT_BORDER), 3049 const_iv (GL_CONSTANT_BORDER),
3050 const_iv (GL_POINTS),
2322 const_iv (GL_LINES), 3051 const_iv (GL_LINES),
2323 const_iv (GL_LINE_STRIP), 3052 const_iv (GL_LINE_STRIP),
2324 const_iv (GL_LINE_LOOP), 3053 const_iv (GL_LINE_LOOP),
2325 const_iv (GL_QUADS), 3054 const_iv (GL_QUADS),
2326 const_iv (GL_QUAD_STRIP), 3055 const_iv (GL_QUAD_STRIP),
2327 const_iv (GL_TRIANGLES), 3056 const_iv (GL_TRIANGLES),
2328 const_iv (GL_TRIANGLE_STRIP), 3057 const_iv (GL_TRIANGLE_STRIP),
2329 const_iv (GL_TRIANGLE_FAN), 3058 const_iv (GL_TRIANGLE_FAN),
3059 const_iv (GL_POLYGON),
2330 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),
2331 const_iv (GL_FASTEST), 3066 const_iv (GL_FASTEST),
3067 const_iv (GL_DONT_CARE),
3068 const_iv (GL_NICEST),
2332 const_iv (GL_V2F), 3069 const_iv (GL_V2F),
2333 const_iv (GL_V3F), 3070 const_iv (GL_V3F),
2334 const_iv (GL_T2F_V3F), 3071 const_iv (GL_T2F_V3F),
2335 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),
2336# undef const_iv 3076# undef const_iv
2337 }; 3077 };
2338 3078
2339 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; )
2340 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3080 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2341 3081
2342 texture_av = newAV (); 3082 texture_av = newAV ();
2343 AvREAL_off (texture_av); 3083 AvREAL_off (texture_av);
2344} 3084}
2345 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
2346char * 3095char *
2347gl_vendor () 3096gl_vendor ()
2348 CODE: 3097 CODE:
2349 RETVAL = (char *)glGetString (GL_VENDOR); 3098 RETVAL = (char *)glGetString (GL_VENDOR);
2350 OUTPUT: 3099 OUTPUT:
… …
2399 3148
2400void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3149void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2401 CODE: 3150 CODE:
2402 gl_BlendFuncSeparate (sa, da, saa, daa); 3151 gl_BlendFuncSeparate (sa, da, saa, daa);
2403 3152
3153# void glBlendEquation (int se)
3154
2404void glDepthMask (int flag) 3155void glDepthMask (int flag)
2405 3156
2406void glLogicOp (int opcode) 3157void glLogicOp (int opcode)
2407 3158
2408void glColorMask (int red, int green, int blue, int alpha) 3159void glColorMask (int red, int green, int blue, int alpha)
… …
2422# near_ and far_ are due to microsofts buggy "c" compiler 3173# near_ and far_ are due to microsofts buggy "c" compiler
2423void 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_)
2424 3175
2425# near_ and far_ are due to microsofts buggy "c" compiler 3176# near_ and far_ are due to microsofts buggy "c" compiler
2426void 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
2427 3180
2428void glViewport (int x, int y, int width, int height) 3181void glViewport (int x, int y, int width, int height)
2429 3182
2430void glScissor (int x, int y, int width, int height) 3183void glScissor (int x, int y, int width, int height)
2431 3184
… …
2439 3192
2440void glRotate (float angle, float x, float y, float z) 3193void glRotate (float angle, float x, float y, float z)
2441 CODE: 3194 CODE:
2442 glRotatef (angle, x, y, z); 3195 glRotatef (angle, x, y, z);
2443 3196
2444void glBegin (int mode)
2445
2446void glEnd ()
2447
2448void glColor (float r, float g, float b, float a = 1.0) 3197void glColor (float r, float g, float b, float a = 1.0)
2449 PROTOTYPE: @ 3198 PROTOTYPE: @
2450 ALIAS: 3199 ALIAS:
2451 glColor_premultiply = 1 3200 glColor_premultiply = 1
2452 CODE: 3201 CODE:
2453 if (ix) 3202 if (ix)
2454 { 3203 {
… …
2457 b *= a; 3206 b *= a;
2458 } 3207 }
2459 // microsoft visual "c" rounds instead of truncating... 3208 // microsoft visual "c" rounds instead of truncating...
2460 glColor4f (r, g, b, a); 3209 glColor4f (r, g, b, a);
2461 3210
2462void glInterleavedArrays (int format, int stride, char *data)
2463
2464void glDrawElements (int mode, int count, int type, char *indices)
2465
2466# 1.2 void glDrawRangeElements (int mode, int start, int end
2467
2468void glRasterPos (float x, float y, float z = 0.) 3211void glRasterPos (float x, float y, float z = 0.)
2469 CODE: 3212 CODE:
2470 glRasterPos3f (0, 0, z); 3213 glRasterPos3f (0, 0, z);
2471 glBitmap (0, 0, 0, 0, x, y, 0); 3214 glBitmap (0, 0, 0, 0, x, y, 0);
2472 3215
… …
2476 3219
2477void glTexCoord (float s, float t) 3220void glTexCoord (float s, float t)
2478 CODE: 3221 CODE:
2479 glTexCoord2f (s, t); 3222 glTexCoord2f (s, t);
2480 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
2481void glTexEnv (int target, int pname, float param) 3253void glTexEnv (int target, int pname, float param)
2482 CODE: 3254 CODE:
2483 glTexEnvf (target, pname, param); 3255 glTexEnvf (target, pname, param);
2484 3256
2485void glTexParameter (int target, int pname, float param) 3257void glTexParameter (int target, int pname, float param)
… …
2501void 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)
2502 CODE: 3274 CODE:
2503 if (gl.SeparableFilter2D) 3275 if (gl.SeparableFilter2D)
2504 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3276 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2505 3277
2506void 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)
2507 3279
2508void 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)
2509 3281
2510void glDrawPixels (int width, int height, int format, int type, char *pixels) 3282void glDrawPixels (int width, int height, int format, int type, char *pixels)
2511 3283
… …
2537 3309
2538void glEndList () 3310void glEndList ()
2539 3311
2540void glCallList (int list) 3312void glCallList (int list)
2541 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