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.177 by root, Tue Apr 10 10:13:10 2007 UTC vs.
Revision 1.297 by root, Tue Dec 22 00:08:11 2009 UTC

… …
6# include <wininet.h> 6# include <wininet.h>
7# pragma warning(disable:4244) 7# pragma warning(disable:4244)
8# pragma warning(disable:4761) 8# pragma warning(disable:4761)
9#endif 9#endif
10 10
11//#define DEBUG 1
12#if DEBUG
13# include <valgrind/memcheck.h>
14#endif
15
11#include "EXTERN.h" 16#include "EXTERN.h"
12#include "perl.h" 17#include "perl.h"
13#include "XSUB.h" 18#include "XSUB.h"
14 19
15#ifdef _WIN32 20#ifdef _WIN32
16# undef pipe 21# undef pipe
22// microsoft vs. C
23# define sqrtf(x) sqrt(x)
24# define atan2f(x,y) atan2(x,y)
25# define M_PI 3.14159265f
17#endif 26#endif
18 27
19#include <assert.h> 28#include <assert.h>
20#include <math.h> 29#include <math.h>
21#include <string.h> 30#include <string.h>
22#include <stdio.h> 31#include <stdio.h>
23#include <stdlib.h> 32#include <stdlib.h>
24 33
34#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
35
25#include <SDL.h> 36#include <SDL.h>
37#include <SDL_thread.h>
26#include <SDL_endian.h> 38#include <SDL_endian.h>
27#include <SDL_image.h> 39#include <SDL_image.h>
28#include <SDL_mixer.h> 40#include <SDL_mixer.h>
29#include <SDL_opengl.h> 41#include <SDL_opengl.h>
30 42
43/* work around os x broken headers */
44#ifdef __MACOSX__
45typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
46#endif
47
31#define PANGO_ENABLE_BACKEND 48#define PANGO_ENABLE_BACKEND
32#define G_DISABLE_CAST_CHECKS 49#define G_DISABLE_CAST_CHECKS
33 50
34#include <glib/gmacros.h> 51#include <glib/gmacros.h>
35 52
36#include <pango/pango.h> 53#include <pango/pango.h>
54
55#ifndef PANGO_VERSION_CHECK
56# define PANGO_VERSION_CHECK(a,b,c) 0
57#endif
58
59#if !PANGO_VERSION_CHECK (1, 15, 2)
60# define pango_layout_get_line_readonly pango_layout_get_line
61# define pango_layout_get_lines_readonly pango_layout_get_lines
62# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line
63# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run
64#endif
37 65
38#ifndef _WIN32 66#ifndef _WIN32
39# include <sys/types.h> 67# include <sys/types.h>
40# include <sys/socket.h> 68# include <sys/socket.h>
41# include <netinet/in.h> 69# include <netinet/in.h>
42# include <netinet/tcp.h> 70# include <netinet/tcp.h>
43# include <inttypes.h> 71# include <inttypes.h>
44#endif 72#endif
45 73
74#if __GNUC__ >= 4
75# define expect(expr,value) __builtin_expect ((expr),(value))
76#else
77# define expect(expr,value) (expr)
78#endif
79
80#define expect_false(expr) expect ((expr) != 0, 0)
81#define expect_true(expr) expect ((expr) != 0, 1)
82
46#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 83#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
47 84
85/* this is used as fow flag as well, so has to have a different value */
86/* then anything that is computed by incoming darkness */
48#define FOW_DARKNESS 32 87#define FOW_DARKNESS 50
88#define DARKNESS_ADJUST(n) (n)
49 89
50#define MAP_EXTEND_X 32 90#define MAP_EXTEND_X 32
51#define MAP_EXTEND_Y 512 91#define MAP_EXTEND_Y 512
52 92
53#define MIN_FONT_HEIGHT 10 93#define MIN_FONT_HEIGHT 10
54 94
55#if 0 95/* mask out modifiers we are not interested in */
56# define PARACHUTE SDL_INIT_NOPARACHUTE 96#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
57#else 97
58# define PARACHUTE 0 98#define KMOD_LRAM 0x10000 // our extension
59#endif 99
100#define TEXID_SPEECH 1
101#define TEXID_NOFACE 2
102
103static AV *texture_av;
60 104
61static struct 105static struct
62{ 106{
63#define GL_FUNC(ptr,name) ptr name; 107#define GL_FUNC(ptr,name) ptr name;
64#include "glfunc.h" 108#include "glfunc.h"
65#undef GL_FUNC 109#undef GL_FUNC
66} gl; 110} gl;
67 111
112static void
68static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa) 113gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
69{ 114{
70 if (gl.BlendFuncSeparate) 115 if (gl.BlendFuncSeparate)
71 gl.BlendFuncSeparate (sa, da, saa, daa); 116 gl.BlendFuncSeparate (sa, da, saa, daa);
72 else if (gl.BlendFuncSeparateEXT) 117 else if (gl.BlendFuncSeparateEXT)
73 gl.BlendFuncSeparateEXT (sa, da, saa, daa); 118 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
74 else 119 else
75 glBlendFunc (sa, da); 120 glBlendFunc (sa, da);
76} 121}
77 122
123static GLuint
124gen_texture ()
125{
126 GLuint name;
127
128 if (AvFILL (texture_av) >= 0)
129 name = (GLuint)(size_t)av_pop (texture_av);
130 else
131 glGenTextures (1, &name);
132
133 return name;
134}
135
136static void
137del_texture (GLuint name)
138{
139 /* make a half-assed attempt at returning the memory used by the texture */
140 /* textures are frequently being reused by cfplus anyway */
141 /*glBindTexture (GL_TEXTURE_2D, name);*/
142 /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
143 av_push (texture_av, (SV *)(size_t)name);
144 glDeleteTextures (1, &name);
145}
146
78#include "texcache.c" 147#include "texcache.c"
148#include "rendercache.c"
79 149
80#include "pango-font.c" 150#include "pango-font.c"
81#include "pango-fontmap.c" 151#include "pango-fontmap.c"
82#include "pango-render.c" 152#include "pango-render.c"
83 153
154typedef IV DC__Channel;
155typedef SDL_RWops *DC__RW;
84typedef Mix_Chunk *CFPlus__MixChunk; 156typedef Mix_Chunk *DC__MixChunk;
85typedef Mix_Music *CFPlus__MixMusic; 157typedef Mix_Music *DC__MixMusic;
86 158
87typedef PangoFontDescription *CFPlus__Font; 159typedef PangoFontDescription *DC__Font;
88 160
89static int 161static int
90shape_attr_p (PangoLayoutRun *run) 162shape_attr_p (PangoLayoutRun *run)
91{ 163{
92 GSList *attrs = run->item->analysis.extra_attrs; 164 GSList *attrs = run->item->analysis.extra_attrs;
… …
106 178
107typedef struct cf_layout { 179typedef struct cf_layout {
108 PangoLayout *pl; 180 PangoLayout *pl;
109 float r, g, b, a; // default color for rgba mode 181 float r, g, b, a; // default color for rgba mode
110 int base_height; 182 int base_height;
111 CFPlus__Font font; 183 DC__Font font;
184 rc_t *rc;
112} *CFPlus__Layout; 185} *DC__Layout;
113 186
114static CFPlus__Font default_font; 187static DC__Font default_font;
115static PangoContext *opengl_context; 188static PangoContext *opengl_context;
116static PangoFontMap *opengl_fontmap; 189static PangoFontMap *opengl_fontmap;
117 190
118static void 191static void
119substitute_func (FcPattern *pattern, gpointer data) 192substitute_func (FcPattern *pattern, gpointer data)
… …
124#endif 197#endif
125 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 198 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
126} 199}
127 200
128static void 201static void
129layout_update_font (CFPlus__Layout self) 202layout_update_font (DC__Layout self)
130{ 203{
131 /* 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
132 * reasonably well with bitstream vera 205 * reasonably well with dejavu/bistream fonts
133 */ 206 */
134 PangoFontDescription *font = self->font ? self->font : default_font; 207 PangoFontDescription *font = self->font ? self->font : default_font;
135 208
136 pango_font_description_set_absolute_size (font, 209 pango_font_description_set_absolute_size (font,
137 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 210 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
138 211
139 pango_layout_set_font_description (self->pl, font); 212 pango_layout_set_font_description (self->pl, font);
140} 213}
141 214
142static void 215static void
143layout_get_pixel_size (CFPlus__Layout self, int *w, int *h) 216layout_get_pixel_size (DC__Layout self, int *w, int *h)
144{ 217{
145 PangoRectangle rect; 218 PangoRectangle rect;
146 219
147 // get_pixel_* wrongly rounds down 220 // get_pixel_* wrongly rounds down
148 pango_layout_get_extents (self->pl, 0, &rect); 221 pango_layout_get_extents (self->pl, 0, &rect);
… …
159 232
160typedef uint16_t tileid; 233typedef uint16_t tileid;
161typedef uint16_t faceid; 234typedef uint16_t faceid;
162 235
163typedef struct { 236typedef struct {
164 int name; 237 GLuint name;
165 int w, h; 238 int w, h;
166 float s, t; 239 float s, t;
167 uint8_t r, g, b, a; 240 uint8_t r, g, b, a;
168 tileid smoothtile; 241 tileid smoothtile;
169 uint8_t smoothlevel; 242 uint8_t smoothlevel;
243 uint8_t unused; /* set to zero on use */
170} maptex; 244} maptex;
171 245
172typedef struct { 246typedef struct {
173 uint32_t player; 247 uint32_t player;
174 tileid tile[3]; 248 tileid tile[3];
… …
187 int faces; tileid *face2tile; // [faceid] 261 int faces; tileid *face2tile; // [faceid]
188 int texs; maptex *tex; // [tileid] 262 int texs; maptex *tex; // [tileid]
189 263
190 int32_t rows; 264 int32_t rows;
191 maprow *row; 265 maprow *row;
192} *CFPlus__Map; 266} *DC__Map;
193 267
194static char * 268static char *
195prepend (char *ptr, int sze, int inc) 269prepend (char *ptr, int sze, int inc)
196{ 270{
197 char *p; 271 char *p;
… …
235 self->texs *= 2; 309 self->texs *= 2;
236 } 310 }
237} 311}
238 312
239static maprow * 313static maprow *
240map_get_row (CFPlus__Map self, int y) 314map_get_row (DC__Map self, int y)
241{ 315{
242 if (0 > y) 316 if (0 > y)
243 { 317 {
244 int extend = - y + MAP_EXTEND_Y; 318 int extend = - y + MAP_EXTEND_Y;
245 Prepend (maprow, self->row, self->rows, extend); 319 Prepend (maprow, self->row, self->rows, extend);
… …
283 357
284 return row->col + (x - row->c0); 358 return row->col + (x - row->c0);
285} 359}
286 360
287static mapcell * 361static mapcell *
288map_get_cell (CFPlus__Map self, int x, int y) 362map_get_cell (DC__Map self, int x, int y)
289{ 363{
290 return row_get_cell (map_get_row (self, y), x); 364 return row_get_cell (map_get_row (self, y), x);
291} 365}
292 366
293static void 367static void
294map_clear (CFPlus__Map self) 368map_clear (DC__Map self)
295{ 369{
296 int r; 370 int r;
297 371
298 for (r = 0; r < self->rows; r++) 372 for (r = 0; r < self->rows; r++)
299 Safefree (self->row[r].col); 373 Safefree (self->row[r].col);
… …
306 self->oy = 0; 380 self->oy = 0;
307 self->row = 0; 381 self->row = 0;
308 self->rows = 0; 382 self->rows = 0;
309} 383}
310 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
311static void 395static void
312map_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)
313{ 397{
314 int x, y; 398 int x, y;
315 maprow *row; 399 maprow *row;
316 mapcell *cell; 400 mapcell *cell;
317 401
… …
329 if (x >= row->c1) 413 if (x >= row->c1)
330 break; 414 break;
331 415
332 cell = row->col + x - row->c0; 416 cell = row->col + x - row->c0;
333 417
334 cell->darkness = 0; 418 CELL_CLEAR (cell);
335 cell->stat_hp = 0;
336 cell->flags = 0;
337 cell->player = 0;
338 } 419 }
339 } 420 }
340} 421}
341 422
342typedef struct { 423typedef struct {
… …
345} smooth_key; 426} smooth_key;
346 427
347static void 428static void
348smooth_or_bits (HV *hv, smooth_key *key, IV bits) 429smooth_or_bits (HV *hv, smooth_key *key, IV bits)
349{ 430{
350 SV **sv = hv_fetch (hv, (char *)key, sizeof (key), 1); 431 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
351 432
352 if (SvIOK (*sv)) 433 if (SvIOK (*sv))
353 SvIV_set (*sv, SvIVX (*sv) | bits); 434 SvIV_set (*sv, SvIVX (*sv) | bits);
354 else 435 else
355 sv_setiv (*sv, bits); 436 sv_setiv (*sv, bits);
… …
396 n |= n >> 16; 477 n |= n >> 16;
397 478
398 return n + 1; 479 return n + 1;
399} 480}
400 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
401/* SDL should provide this, really. */ 493/* SDL should provide this, really. */
402#define SDLK_MODIFIER_MIN 300 494#define SDLK_MODIFIER_MIN 300
403#define SDLK_MODIFIER_MAX 314 495#define SDLK_MODIFIER_MAX 314
404 496
405MODULE = 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
406 593
407PROTOTYPES: ENABLE 594PROTOTYPES: ENABLE
408 595
409BOOT: 596BOOT:
410{ 597{
411 HV *stash = gv_stashpv ("CFPlus", 1); 598 HV *stash = gv_stashpv ("DC", 1);
412 static const struct { 599 static const struct {
413 const char *name; 600 const char *name;
414 IV iv; 601 IV iv;
415 } *civ, const_iv[] = { 602 } *civ, const_iv[] = {
416# define const_iv(name) { # name, (IV)name } 603# define const_iv(name) { # name, (IV)name }
… …
438 625
439 const_iv (SDL_APPINPUTFOCUS), 626 const_iv (SDL_APPINPUTFOCUS),
440 const_iv (SDL_APPMOUSEFOCUS), 627 const_iv (SDL_APPMOUSEFOCUS),
441 const_iv (SDL_APPACTIVE), 628 const_iv (SDL_APPACTIVE),
442 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),
443 const_iv (SDLK_KP0), 682 const_iv (SDLK_KP0),
444 const_iv (SDLK_KP1), 683 const_iv (SDLK_KP1),
445 const_iv (SDLK_KP2), 684 const_iv (SDLK_KP2),
446 const_iv (SDLK_KP3), 685 const_iv (SDLK_KP3),
447 const_iv (SDLK_KP4), 686 const_iv (SDLK_KP4),
… …
519 const_iv (KMOD_LMETA), 758 const_iv (KMOD_LMETA),
520 const_iv (KMOD_RMETA), 759 const_iv (KMOD_RMETA),
521 const_iv (KMOD_NUM), 760 const_iv (KMOD_NUM),
522 const_iv (KMOD_CAPS), 761 const_iv (KMOD_CAPS),
523 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)
524# undef const_iv 796# undef const_iv
525 }; 797 };
526 798
527 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; )
528 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 800 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
… …
546 818
547NV floor (NV x) 819NV floor (NV x)
548 820
549NV ceil (NV x) 821NV ceil (NV x)
550 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
551void 833void
552pango_init () 834pango_init ()
553 CODE: 835 CODE:
554{ 836{
555 opengl_fontmap = pango_opengl_font_map_new (); 837 opengl_fontmap = pango_opengl_font_map_new ();
556 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);
557 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
558} 845}
559 846
560int 847char *SDL_GetError ()
561SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
562 848
563void 849void SDL_braino ()
850
851int SDL_Init (U32 flags)
852
853int SDL_InitSubSystem (U32 flags)
854
855void SDL_QuitSubSystem (U32 flags)
856
564SDL_Quit () 857void SDL_Quit ()
565 858
859int SDL_GL_SetAttribute (int attr, int value)
860
861int SDL_GL_GetAttribute (int attr)
862 CODE:
863 if (SDL_GL_GetAttribute (attr, &RETVAL))
864 XSRETURN_UNDEF;
865 OUTPUT:
866 RETVAL
867
566void 868void
567SDL_ListModes () 869SDL_ListModes (int rgb, int alpha)
568 PPCODE: 870 PPCODE:
569{ 871{
570 SDL_Rect **m; 872 SDL_Rect **m;
571 873
572 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 874 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
573 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 875 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
574 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 876 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
575 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 877 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
576 878
577 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 879 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
578 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 880 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
579 881
580 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 882 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
581 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 883 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
582 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 884 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
583 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 885 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
584 886
585 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 887 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
586#if SDL_VERSION_ATLEAST(1,2,10)
587 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
588 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 888 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
589#endif
590
591 SDL_EnableUNICODE (1);
592 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
593 889
594 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 890 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
595 891
596 if (m && m != (SDL_Rect **)-1) 892 if (m && m != (SDL_Rect **)-1)
597 while (*m) 893 while (*m)
598 { 894 {
895 if ((*m)->w >= 400 && (*m)->h >= 300)
896 {
599 AV *av = newAV (); 897 AV *av = newAV ();
600 av_push (av, newSViv ((*m)->w)); 898 av_push (av, newSViv ((*m)->w));
601 av_push (av, newSViv ((*m)->h)); 899 av_push (av, newSViv ((*m)->h));
900 av_push (av, newSViv (rgb));
901 av_push (av, newSViv (alpha));
602 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 902 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
903 }
603 904
604 ++m; 905 ++m;
605 } 906 }
606} 907}
607 908
608char *
609SDL_GetError ()
610
611int 909int
612SDL_SetVideoMode (int w, int h, int fullscreen) 910SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
613 CODE: 911 CODE:
912{
913 SDL_EnableUNICODE (1);
914 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
915
916 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
917 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
918 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
919 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
920
614 RETVAL = !!SDL_SetVideoMode ( 921 RETVAL = !!SDL_SetVideoMode (
615 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 922 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
616 ); 923 );
924
617 if (RETVAL) 925 if (RETVAL)
618 { 926 {
619 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 927 av_clear (texture_av);
928
929 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
620# 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);
621# include "glfunc.h" 931#include "glfunc.h"
622# undef GL_FUNC 932#undef GL_FUNC
623 } 933 }
934}
624 OUTPUT: 935 OUTPUT:
625 RETVAL 936 RETVAL
626 937
627void 938void
628SDL_GL_SwapBuffers () 939SDL_GL_SwapBuffers ()
629 940
630char * 941char *
631SDL_GetKeyName (int sym) 942SDL_GetKeyName (int sym)
632 943
944int
945SDL_GetAppState ()
946
947int
948SDL_GetModState ()
949
633void 950void
634SDL_PollEvent () 951poll_events ()
635 PPCODE: 952 PPCODE:
636{ 953{
637 SDL_Event ev; 954 SDL_Event ev;
638 955
639 while (SDL_PollEvent (&ev)) 956 SDL_PumpEvents ();
957 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
640 { 958 {
641 HV *hv = newHV (); 959 HV *hv = newHV ();
642 hv_store (hv, "type", 4, newSViv (ev.type), 0); 960 hv_store (hv, "type", 4, newSViv (ev.type), 0);
643 961
644 switch (ev.type) 962 switch (ev.type)
645 { 963 {
646 case SDL_KEYDOWN: 964 case SDL_KEYDOWN:
647 case SDL_KEYUP: 965 case SDL_KEYUP:
648 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 966 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
649 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 967 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
650 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);
651 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 */
652 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 970 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
653 break; 971 break;
654 972
655 case SDL_ACTIVEEVENT: 973 case SDL_ACTIVEEVENT:
656 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 974 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
657 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 975 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
658 break; 976 break;
659 977
660 case SDL_MOUSEMOTION: 978 case SDL_MOUSEMOTION:
979 {
980 int state = ev.motion.state;
981 int x = ev.motion.x;
982 int y = ev.motion.y;
983 int xrel = ev.motion.xrel;
984 int yrel = ev.motion.yrel;
985
986 /* do simplistic event compression */
987 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
988 && state == ev.motion.state)
989 {
990 xrel += ev.motion.xrel;
991 yrel += ev.motion.yrel;
992 x = ev.motion.x;
993 y = ev.motion.y;
994 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
995 }
996
661 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 997 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
662
663 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 998 hv_store (hv, "state", 5, newSViv (state), 0);
664 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 999 hv_store (hv, "x", 1, newSViv (x), 0);
665 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 1000 hv_store (hv, "y", 1, newSViv (y), 0);
666 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 1001 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
667 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 1002 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
1003 }
668 break; 1004 break;
669 1005
670 case SDL_MOUSEBUTTONDOWN: 1006 case SDL_MOUSEBUTTONDOWN:
671 case SDL_MOUSEBUTTONUP: 1007 case SDL_MOUSEBUTTONUP:
672 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1008 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
673 1009
674 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 1010 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
675 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 1011 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
676 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 1012 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
677 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 1013 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
… …
682 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 1018 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
683 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 1019 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
684 break; 1020 break;
685 } 1021 }
686 1022
687 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))));
688 } 1024 }
689} 1025}
690 1026
691int 1027int
692Mix_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)
693 POSTCALL: 1029 POSTCALL:
694 Mix_HookMusicFinished (music_finished); 1030 Mix_HookMusicFinished (music_finished);
695 Mix_ChannelFinished (channel_finished); 1031 Mix_ChannelFinished (channel_finished);
696 1032
697void 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
698Mix_CloseAudio () 1050Mix_CloseAudio ()
699 1051
700int 1052int
701Mix_AllocateChannels (int numchans = -1) 1053Mix_AllocateChannels (int numchans = -1)
702 1054
1055const char *
1056Mix_GetError ()
1057
703void 1058void
704lowdelay (int fd, int val = 1) 1059lowdelay (int fd, int val = 1)
705 CODE: 1060 CODE:
706#ifndef _WIN32
707 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 1061 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
708#endif
709 1062
710void 1063void
711win32_proxy_info () 1064win32_proxy_info ()
712 PPCODE: 1065 PPCODE:
713{ 1066{
… …
734 } 1087 }
735 } 1088 }
736#endif 1089#endif
737} 1090}
738 1091
739void 1092int
740add_font (char *file) 1093add_font (char *file)
741 CODE: 1094 CODE:
742 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1095 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1096 OUTPUT:
1097 RETVAL
743 1098
744void 1099void
745load_image_inline (SV *image_) 1100load_image_inline (SV *image_)
746 ALIAS: 1101 ALIAS:
747 load_image_file = 1 1102 load_image_file = 1
… …
750 STRLEN image_len; 1105 STRLEN image_len;
751 char *image = (char *)SvPVbyte (image_, image_len); 1106 char *image = (char *)SvPVbyte (image_, image_len);
752 SDL_Surface *surface, *surface2; 1107 SDL_Surface *surface, *surface2;
753 SDL_PixelFormat fmt; 1108 SDL_PixelFormat fmt;
754 SDL_RWops *rw = ix 1109 SDL_RWops *rw = ix
755 ? SDL_RWFromFile (image, "r") 1110 ? SDL_RWFromFile (image, "rb")
756 : SDL_RWFromConstMem (image, image_len); 1111 : SDL_RWFromConstMem (image, image_len);
757 1112
758 if (!rw) 1113 if (!rw)
759 croak ("load_image: %s", SDL_GetError ()); 1114 croak ("load_image: %s", SDL_GetError ());
760 1115
… …
833void 1188void
834error (char *message) 1189error (char *message)
835 CODE: 1190 CODE:
836 fprintf (stderr, "ERROR: %s\n", message); 1191 fprintf (stderr, "ERROR: %s\n", message);
837#ifdef _WIN32 1192#ifdef _WIN32
838 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR); 1193 MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
839#endif 1194#endif
840 1195
841void 1196void
842fatal (char *message) 1197fatal (char *message)
843 CODE: 1198 CODE:
844 fprintf (stderr, "FATAL: %s\n", message); 1199 fprintf (stderr, "FATAL: %s\n", message);
845#ifdef _WIN32 1200#ifdef _WIN32
846 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 1201 MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
847#endif 1202#endif
848 _exit (1); 1203 _exit (1);
849 1204
850void 1205void
851_exit (int retval = 0) 1206_exit (int retval = 0)
… …
854 ExitThread (retval); // unclean, please beam me up 1209 ExitThread (retval); // unclean, please beam me up
855#else 1210#else
856 _exit (retval); 1211 _exit (retval);
857#endif 1212#endif
858 1213
859MODULE = CFPlus PACKAGE = CFPlus::Font 1214void
1215debug ()
1216 CODE:
1217{
1218#if DEBUG
1219 VALGRIND_DO_LEAK_CHECK;
1220#endif
1221}
860 1222
861CFPlus::Font 1223int
1224SvREFCNT (SV *sv)
1225 CODE:
1226 RETVAL = SvREFCNT (sv);
1227 OUTPUT:
1228 RETVAL
1229
1230MODULE = Deliantra::Client PACKAGE = DC::Font
1231
1232PROTOTYPES: DISABLE
1233
1234DC::Font
862new_from_file (SV *class, char *path, int id = 0) 1235new_from_file (SV *class, char *path, int id = 0)
863 CODE: 1236 CODE:
864{ 1237{
865 int count; 1238 int count;
866 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1239 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
… …
869} 1242}
870 OUTPUT: 1243 OUTPUT:
871 RETVAL 1244 RETVAL
872 1245
873void 1246void
874DESTROY (CFPlus::Font self) 1247DESTROY (DC::Font self)
875 CODE: 1248 CODE:
876 pango_font_description_free (self); 1249 pango_font_description_free (self);
877 1250
878void 1251void
879make_default (CFPlus::Font self) 1252make_default (DC::Font self)
1253 PROTOTYPE: $
880 CODE: 1254 CODE:
881 default_font = self; 1255 default_font = self;
882 1256
883MODULE = CFPlus PACKAGE = CFPlus::Layout 1257MODULE = Deliantra::Client PACKAGE = DC::Layout
884 1258
1259PROTOTYPES: DISABLE
1260
885void 1261void
886reset_glyph_cache () 1262glyph_cache_backup ()
1263 PROTOTYPE:
887 CODE: 1264 CODE:
1265 tc_backup ();
1266
1267void
1268glyph_cache_restore ()
1269 PROTOTYPE:
1270 CODE:
888 tc_clear (); 1271 tc_restore ();
889 1272
890CFPlus::Layout 1273DC::Layout
891new (SV *class) 1274new (SV *class)
892 CODE: 1275 CODE:
893 New (0, RETVAL, 1, struct cf_layout); 1276 New (0, RETVAL, 1, struct cf_layout);
894 1277
895 RETVAL->pl = pango_layout_new (opengl_context); 1278 RETVAL->pl = pango_layout_new (opengl_context);
… …
897 RETVAL->g = 1.; 1280 RETVAL->g = 1.;
898 RETVAL->b = 1.; 1281 RETVAL->b = 1.;
899 RETVAL->a = 1.; 1282 RETVAL->a = 1.;
900 RETVAL->base_height = MIN_FONT_HEIGHT; 1283 RETVAL->base_height = MIN_FONT_HEIGHT;
901 RETVAL->font = 0; 1284 RETVAL->font = 0;
1285 RETVAL->rc = rc_alloc ();
902 1286
903 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1287 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
904 layout_update_font (RETVAL); 1288 layout_update_font (RETVAL);
905 OUTPUT: 1289 OUTPUT:
906 RETVAL 1290 RETVAL
907 1291
908void 1292void
909DESTROY (CFPlus::Layout self) 1293DESTROY (DC::Layout self)
910 CODE: 1294 CODE:
911 g_object_unref (self->pl); 1295 g_object_unref (self->pl);
1296 rc_free (self->rc);
912 Safefree (self); 1297 Safefree (self);
913 1298
914void 1299void
915set_text (CFPlus::Layout self, SV *text_) 1300set_text (DC::Layout self, SV *text_)
916 CODE: 1301 CODE:
917{ 1302{
918 STRLEN textlen; 1303 STRLEN textlen;
919 char *text = SvPVutf8 (text_, textlen); 1304 char *text = SvPVutf8 (text_, textlen);
920 1305
921 pango_layout_set_text (self->pl, text, textlen); 1306 pango_layout_set_text (self->pl, text, textlen);
922} 1307}
923 1308
924void 1309void
925set_markup (CFPlus::Layout self, SV *text_) 1310set_markup (DC::Layout self, SV *text_)
926 CODE: 1311 CODE:
927{ 1312{
928 STRLEN textlen; 1313 STRLEN textlen;
929 char *text = SvPVutf8 (text_, textlen); 1314 char *text = SvPVutf8 (text_, textlen);
930 1315
931 pango_layout_set_markup (self->pl, text, textlen); 1316 pango_layout_set_markup (self->pl, text, textlen);
932} 1317}
933 1318
934void 1319void
935set_shapes (CFPlus::Layout self, ...) 1320set_shapes (DC::Layout self, ...)
936 CODE: 1321 CODE:
937{ 1322{
938 PangoAttrList *attrs = 0; 1323 PangoAttrList *attrs = 0;
939 const char *text = pango_layout_get_text (self->pl); 1324 const char *text = pango_layout_get_text (self->pl);
940 const char *pos = text; 1325 const char *pos = text;
… …
975 if (attrs) 1360 if (attrs)
976 pango_layout_set_attributes (self->pl, attrs); 1361 pango_layout_set_attributes (self->pl, attrs);
977} 1362}
978 1363
979void 1364void
980get_shapes (CFPlus::Layout self) 1365get_shapes (DC::Layout self)
981 PPCODE: 1366 PPCODE:
982{ 1367{
983 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1368 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
984 1369
985 do 1370 do
986 { 1371 {
987 PangoLayoutRun *run = pango_layout_iter_get_run (iter); 1372 PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
988 1373
989 if (run && shape_attr_p (run)) 1374 if (run && shape_attr_p (run))
990 { 1375 {
991 PangoRectangle extents; 1376 PangoRectangle extents;
992 pango_layout_iter_get_run_extents (iter, 0, &extents); 1377 pango_layout_iter_get_run_extents (iter, 0, &extents);
… …
1000 1385
1001 pango_layout_iter_free (iter); 1386 pango_layout_iter_free (iter);
1002} 1387}
1003 1388
1004int 1389int
1005has_wrapped (CFPlus::Layout self) 1390has_wrapped (DC::Layout self)
1006 CODE: 1391 CODE:
1007{ 1392{
1008 int lines = 1; 1393 int lines = 1;
1009 const char *text = pango_layout_get_text (self->pl); 1394 const char *text = pango_layout_get_text (self->pl);
1010 1395
… …
1015} 1400}
1016 OUTPUT: 1401 OUTPUT:
1017 RETVAL 1402 RETVAL
1018 1403
1019SV * 1404SV *
1020get_text (CFPlus::Layout self) 1405get_text (DC::Layout self)
1021 CODE: 1406 CODE:
1022 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1407 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1023 sv_utf8_decode (RETVAL); 1408 sv_utf8_decode (RETVAL);
1024 OUTPUT: 1409 OUTPUT:
1025 RETVAL 1410 RETVAL
1026 1411
1027void 1412void
1028set_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.)
1029 CODE: 1414 CODE:
1030 self->r = r; 1415 self->r = r;
1031 self->g = g; 1416 self->g = g;
1032 self->b = b; 1417 self->b = b;
1033 self->a = a; 1418 self->a = a;
1034 1419
1035void 1420void
1036set_font (CFPlus::Layout self, CFPlus::Font font = 0) 1421set_font (DC::Layout self, DC::Font font = 0)
1037 CODE: 1422 CODE:
1038 if (self->font != font) 1423 if (self->font != font)
1039 { 1424 {
1040 self->font = font; 1425 self->font = font;
1041 layout_update_font (self); 1426 layout_update_font (self);
1042 } 1427 }
1043 1428
1044void 1429void
1045set_height (CFPlus::Layout self, int base_height) 1430set_height (DC::Layout self, int base_height)
1046 CODE: 1431 CODE:
1047 if (self->base_height != base_height) 1432 if (self->base_height != base_height)
1048 { 1433 {
1049 self->base_height = base_height; 1434 self->base_height = base_height;
1050 layout_update_font (self); 1435 layout_update_font (self);
1051 } 1436 }
1052 1437
1053void 1438void
1054set_width (CFPlus::Layout self, int max_width = -1) 1439set_width (DC::Layout self, int max_width = -1)
1055 CODE: 1440 CODE:
1056 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);
1057 1442
1058void 1443void
1059set_indent (CFPlus::Layout self, int indent) 1444set_indent (DC::Layout self, int indent)
1060 CODE: 1445 CODE:
1061 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1446 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1062 1447
1063void 1448void
1064set_spacing (CFPlus::Layout self, int spacing) 1449set_spacing (DC::Layout self, int spacing)
1065 CODE: 1450 CODE:
1066 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1451 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1067 1452
1068void 1453void
1069set_ellipsise (CFPlus::Layout self, int ellipsise) 1454set_ellipsise (DC::Layout self, int ellipsise)
1070 CODE: 1455 CODE:
1071 pango_layout_set_ellipsize (self->pl, 1456 pango_layout_set_ellipsize (self->pl,
1072 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1457 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1073 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1458 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1074 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1459 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1075 : PANGO_ELLIPSIZE_NONE 1460 : PANGO_ELLIPSIZE_NONE
1076 ); 1461 );
1077 1462
1078void 1463void
1079set_single_paragraph_mode (CFPlus::Layout self, int spm) 1464set_single_paragraph_mode (DC::Layout self, int spm)
1080 CODE: 1465 CODE:
1081 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1466 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1082 1467
1083void 1468void
1084size (CFPlus::Layout self) 1469size (DC::Layout self)
1085 PPCODE: 1470 PPCODE:
1086{ 1471{
1087 int w, h; 1472 int w, h;
1088 1473
1089 layout_get_pixel_size (self, &w, &h); 1474 layout_get_pixel_size (self, &w, &h);
… …
1092 PUSHs (sv_2mortal (newSViv (w))); 1477 PUSHs (sv_2mortal (newSViv (w)));
1093 PUSHs (sv_2mortal (newSViv (h))); 1478 PUSHs (sv_2mortal (newSViv (h)));
1094} 1479}
1095 1480
1096int 1481int
1097descent (CFPlus::Layout self) 1482descent (DC::Layout self)
1098 CODE: 1483 CODE:
1099{ 1484{
1100 PangoRectangle rect; 1485 PangoRectangle rect;
1101 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1486 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1102 pango_layout_line_get_pixel_extents (line, 0, &rect); 1487 pango_layout_line_get_pixel_extents (line, 0, &rect);
1103 RETVAL = PANGO_DESCENT (rect); 1488 RETVAL = PANGO_DESCENT (rect);
1104} 1489}
1105 OUTPUT: 1490 OUTPUT:
1106 RETVAL 1491 RETVAL
1107 1492
1108int 1493int
1109xy_to_index (CFPlus::Layout self, int x, int y) 1494xy_to_index (DC::Layout self, int x, int y)
1110 CODE: 1495 CODE:
1111{ 1496{
1112 int index, trailing; 1497 int index, trailing;
1113 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);
1114 RETVAL = index + trailing; 1499 RETVAL = index + trailing;
1115} 1500}
1116 OUTPUT: 1501 OUTPUT:
1117 RETVAL 1502 RETVAL
1118 1503
1119void 1504void
1120cursor_pos (CFPlus::Layout self, int index) 1505cursor_pos (DC::Layout self, int index)
1121 PPCODE: 1506 PPCODE:
1122{ 1507{
1123 PangoRectangle strong_pos; 1508 PangoRectangle pos;
1124 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1509 pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1125 1510
1126 EXTEND (SP, 3); 1511 EXTEND (SP, 3);
1127 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1512 PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1128 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1513 PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1129 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1514 PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1130} 1515}
1131 1516
1132void 1517void
1133index_to_line_x (CFPlus::Layout self, int index, int trailing = 0) 1518index_to_line_x (DC::Layout self, int index, int trailing = 0)
1134 PPCODE: 1519 PPCODE:
1135{ 1520{
1136 int line, x; 1521 int line, x;
1137 1522
1138 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)
1139 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1525 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1140 1526 --line;
1527#endif
1141 EXTEND (SP, 2); 1528 EXTEND (SP, 2);
1142 PUSHs (sv_2mortal (newSViv (line - 1))); 1529 PUSHs (sv_2mortal (newSViv (line)));
1143 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE))); 1530 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1144} 1531}
1145 1532
1146void 1533void
1147line_x_to_index (CFPlus::Layout self, int line, int x) 1534line_x_to_index (DC::Layout self, int line, int x)
1148 PPCODE: 1535 PPCODE:
1149{ 1536{
1150 PangoLayoutLine *lp; 1537 PangoLayoutLine *lp;
1151 int index, trailing; 1538 int index, trailing;
1152 1539
1153 if (line < 0) 1540 if (line < 0)
1154 XSRETURN_EMPTY; 1541 XSRETURN_EMPTY;
1155 1542
1156 if (!(lp = pango_layout_get_line (self->pl, line))) 1543 if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1157 XSRETURN_EMPTY; /* do better */ 1544 XSRETURN_EMPTY; /* do better */
1158 1545
1159 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);
1160 1547
1161 EXTEND (SP, 2); 1548 EXTEND (SP, 2);
… …
1167 PUSHs (sv_2mortal (newSViv (trailing))); 1554 PUSHs (sv_2mortal (newSViv (trailing)));
1168 } 1555 }
1169} 1556}
1170 1557
1171void 1558void
1172render (CFPlus::Layout self, float x, float y, int flags = 0) 1559render (DC::Layout self, float x, float y, int flags = 0)
1173 PPCODE: 1560 CODE:
1561 rc_clear (self->rc);
1174 pango_opengl_render_layout_subpixel ( 1562 pango_opengl_render_layout_subpixel (
1175 self->pl, 1563 self->pl,
1564 self->rc,
1176 x * PANGO_SCALE, y * PANGO_SCALE, 1565 x * PANGO_SCALE, y * PANGO_SCALE,
1177 self->r, self->g, self->b, self->a, 1566 self->r, self->g, self->b, self->a,
1178 flags 1567 flags
1179 ); 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);
1180 1572
1181MODULE = CFPlus PACKAGE = CFPlus::Texture
1182
1183void 1573void
1184pad2pot (SV *data_, SV *w_, SV *h_) 1574draw (DC::Layout self)
1185 CODE: 1575 CODE:
1186{ 1576{
1187 int ow = SvIV (w_); 1577 glEnable (GL_TEXTURE_2D);
1188 int oh = SvIV (h_); 1578 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1579 glEnable (GL_BLEND);
1580 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1581 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1582 glEnable (GL_ALPHA_TEST);
1583 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1189 1584
1190 if (ow && oh) 1585 rc_draw (self->rc);
1586
1587 glDisable (GL_ALPHA_TEST);
1588 glDisable (GL_BLEND);
1589 glDisable (GL_TEXTURE_2D);
1590}
1591
1592MODULE = Deliantra::Client PACKAGE = DC::Texture
1593
1594PROTOTYPES: ENABLE
1595
1596void
1597pad (SV *data_, int ow, int oh, int nw, int nh)
1598 CODE:
1599{
1600 if ((nw != ow || nh != oh) && SvOK (data_))
1191 { 1601 {
1192 int nw = minpot (ow);
1193 int nh = minpot (oh);
1194
1195 if (nw != ow || nh != oh)
1196 {
1197 if (SvOK (data_))
1198 {
1199 STRLEN datalen; 1602 STRLEN datalen;
1200 char *data = SvPVbyte (data_, datalen); 1603 char *data = SvPVbyte (data_, datalen);
1201 int bpp = datalen / (ow * oh); 1604 int bpp = datalen / (ow * oh);
1202 SV *result_ = sv_2mortal (newSV (nw * nh * bpp)); 1605 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1203 1606
1204 SvPOK_only (result_); 1607 SvPOK_only (result_);
1205 SvCUR_set (result_, nw * nh * bpp); 1608 SvCUR_set (result_, nw * nh * bpp);
1206 1609
1207 memset (SvPVX (result_), 0, nw * nh * bpp); 1610 memset (SvPVX (result_), 0, nw * nh * bpp);
1208 while (oh--) 1611 while (oh--)
1209 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp); 1612 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1210 1613
1211 sv_setsv (data_, result_); 1614 sv_setsv (data_, result_);
1212 }
1213
1214 sv_setiv (w_, nw);
1215 sv_setiv (h_, nh);
1216 }
1217 } 1615 }
1218} 1616}
1219 1617
1220void 1618void
1221draw_quad (SV *self, float x, float y, float w = 0., float h = 0.) 1619draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
… …
1227{ 1625{
1228 HV *hv = (HV *)SvRV (self); 1626 HV *hv = (HV *)SvRV (self);
1229 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1627 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
1230 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1628 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
1231 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1629 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
1630
1631 if (name <= 0)
1632 XSRETURN_EMPTY;
1232 1633
1233 if (items < 5) 1634 if (items < 5)
1234 { 1635 {
1235 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1636 w = SvNV (*hv_fetch (hv, "w", 1, 1));
1236 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1637 h = SvNV (*hv_fetch (hv, "h", 1, 1));
… …
1264 glDisable (GL_ALPHA_TEST); 1665 glDisable (GL_ALPHA_TEST);
1265 glDisable (GL_BLEND); 1666 glDisable (GL_BLEND);
1266 } 1667 }
1267} 1668}
1268 1669
1269MODULE = CFPlus PACKAGE = CFPlus::Map 1670void
1671draw_fow_texture (float intensity, int hidden_tex, int name1, uint8_t *data1, float s, float t, int w, int h, float blend = 0.f, int dx = 0, int dy = 0, int name2 = 0, uint8_t *data2 = data1)
1672 PROTOTYPE: @
1673 CODE:
1674{
1675 glEnable (GL_TEXTURE_2D);
1676 glEnable (GL_BLEND);
1677 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1678 glBindTexture (GL_TEXTURE_2D, name1);
1270 1679
1271CFPlus::Map 1680 glColor3f (intensity, intensity, intensity);
1681 glPushMatrix ();
1682 glScalef (1./3, 1./3, 1.);
1683
1684 if (blend > 0.f)
1685 {
1686 float dx3 = dx * -3.f / w;
1687 float dy3 = dy * -3.f / h;
1688 GLfloat env_color[4] = { 0., 0., 0., blend };
1689
1690 /* interpolate the two shadow textures */
1691 /* stage 0 == rgb(glcolor) + alpha(t0) */
1692 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1693
1694 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1695 gl.ActiveTexture (GL_TEXTURE1);
1696 glEnable (GL_TEXTURE_2D);
1697 glBindTexture (GL_TEXTURE_2D, name2);
1698 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1699
1700 /* rgb == rgb(glcolor) */
1701 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1702 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
1703 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1704
1705 /* alpha = interpolate t0, t1 by env_alpha */
1706 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1707
1708 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1709 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1710 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1711
1712 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1713 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1714
1715 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1716 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1717
1718 glBegin (GL_QUADS);
1719 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1720 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1721 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1722 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1723 glEnd ();
1724
1725 glDisable (GL_TEXTURE_2D);
1726 gl.ActiveTexture (GL_TEXTURE0);
1727 }
1728 else
1729 {
1730 /* simple blending of one texture, also opengl <1.3 path */
1731 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1732
1733 glBegin (GL_QUADS);
1734 glTexCoord2f (0, 0); glVertex2f (0, 0);
1735 glTexCoord2f (0, t); glVertex2f (0, h);
1736 glTexCoord2f (s, t); glVertex2f (w, h);
1737 glTexCoord2f (s, 0); glVertex2f (w, 0);
1738 glEnd ();
1739 }
1740
1741 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1742 {
1743 int x, y;
1744 int dx3 = dx * 3;
1745 int dy3 = dy * 3;
1746
1747 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1748 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1749 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1750 glTranslatef (-1., -1., 0);
1751 glBegin (GL_QUADS);
1752
1753 for (y = 1; y < h; y += 3)
1754 {
1755 int y1 = y - dy3;
1756 int y1valid = y1 >= 0 && y1 < h;
1757
1758 for (x = 1; x < w; x += 3)
1759 {
1760 int x1 = x - dx3;
1761 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1762 uint8_t h2;
1763
1764 if (y1valid && x1 >= 0 && x1 < w)
1765 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1766 else
1767 h2 = 1; /* out of range == invisible */
1768
1769 if (h1 || h2)
1770 {
1771 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1772 glColor4f (1., 1., 1., alpha);
1773
1774 glTexCoord2f (0, 0.); glVertex2i (x , y );
1775 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1776 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1777 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1778 }
1779 }
1780 }
1781 }
1782
1783 glEnd ();
1784
1785 glPopMatrix ();
1786
1787 glDisable (GL_TEXTURE_2D);
1788 glDisable (GL_BLEND);
1789}
1790
1791IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1792 CODE:
1793{
1794 GLint width;
1795 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1796 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1797 RETVAL = width > 0;
1798}
1799 OUTPUT:
1800 RETVAL
1801
1802MODULE = Deliantra::Client PACKAGE = DC::Map
1803
1804PROTOTYPES: DISABLE
1805
1806DC::Map
1272new (SV *class) 1807new (SV *class)
1273 CODE: 1808 CODE:
1274 New (0, RETVAL, 1, struct map); 1809 New (0, RETVAL, 1, struct map);
1275 RETVAL->x = 0; 1810 RETVAL->x = 0;
1276 RETVAL->y = 0; 1811 RETVAL->y = 0;
… …
1284 RETVAL->row = 0; 1819 RETVAL->row = 0;
1285 OUTPUT: 1820 OUTPUT:
1286 RETVAL 1821 RETVAL
1287 1822
1288void 1823void
1289DESTROY (CFPlus::Map self) 1824DESTROY (DC::Map self)
1290 CODE: 1825 CODE:
1291{ 1826{
1292 map_clear (self); 1827 map_clear (self);
1293 Safefree (self->face2tile); 1828 Safefree (self->face2tile);
1294 Safefree (self->tex); 1829 Safefree (self->tex);
1295 Safefree (self); 1830 Safefree (self);
1296} 1831}
1297 1832
1298void 1833void
1299resize (CFPlus::Map self, int map_width, int map_height) 1834resize (DC::Map self, int map_width, int map_height)
1300 CODE: 1835 CODE:
1301 self->w = map_width; 1836 self->w = map_width;
1302 self->h = map_height; 1837 self->h = map_height;
1303 1838
1304void 1839void
1305clear (CFPlus::Map self) 1840clear (DC::Map self)
1306 CODE: 1841 CODE:
1307 map_clear (self); 1842 map_clear (self);
1308 1843
1309void 1844void
1310set_tileid (CFPlus::Map self, int face, int tile) 1845set_tileid (DC::Map self, int face, int tile)
1311 CODE: 1846 CODE:
1312{ 1847{
1313 need_facenum (self, face); self->face2tile [face] = tile; 1848 need_facenum (self, face); self->face2tile [face] = tile;
1314 need_texid (self, tile); 1849 need_texid (self, tile);
1315} 1850}
1316 1851
1317void 1852void
1318set_smooth (CFPlus::Map self, int face, int smooth, int level) 1853set_smooth (DC::Map self, int face, int smooth, int level)
1319 CODE: 1854 CODE:
1320{ 1855{
1321 tileid texid; 1856 tileid texid;
1322 maptex *tex; 1857 maptex *tex;
1323 1858
… …
1336 tex->smoothtile = self->face2tile [smooth]; 1871 tex->smoothtile = self->face2tile [smooth];
1337 tex->smoothlevel = level; 1872 tex->smoothlevel = level;
1338} 1873}
1339 1874
1340void 1875void
1341set_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)
1342 CODE: 1877 CODE:
1343{ 1878{
1344 need_texid (self, texid); 1879 need_texid (self, texid);
1345 1880
1346 { 1881 {
… …
1365 // use uglier nearest interpolation because linear suffers 1900 // use uglier nearest interpolation because linear suffers
1366 // from transparent color bleeding and ugly wrapping effects. 1901 // from transparent color bleeding and ugly wrapping effects.
1367 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1902 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1368} 1903}
1369 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
1370int 1925int
1371ox (CFPlus::Map self) 1926ox (DC::Map self)
1372 ALIAS: 1927 ALIAS:
1373 oy = 1 1928 oy = 1
1374 x = 2 1929 x = 2
1375 y = 3 1930 y = 3
1376 w = 4 1931 w = 4
… …
1387 } 1942 }
1388 OUTPUT: 1943 OUTPUT:
1389 RETVAL 1944 RETVAL
1390 1945
1391void 1946void
1392scroll (CFPlus::Map self, int dx, int dy) 1947scroll (DC::Map self, int dx, int dy)
1393 CODE: 1948 CODE:
1394{ 1949{
1395 if (dx > 0) 1950 if (dx > 0)
1396 map_blank (self, self->x, self->y, dx, self->h); 1951 map_blank (self, self->x, self->y, dx, self->h);
1397 else if (dx < 0) 1952 else if (dx < 0)
1398 map_blank (self, self->x + self->w + dx + 1, self->y, -dx, self->h); 1953 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
1399 1954
1400 if (dy > 0) 1955 if (dy > 0)
1401 map_blank (self, self->x, self->y, self->w, dy); 1956 map_blank (self, self->x, self->y, self->w, dy);
1402 else if (dy < 0) 1957 else if (dy < 0)
1403 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, -dy); 1958 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
1404 1959
1405 self->ox += dx; self->x += dx; 1960 self->ox += dx; self->x += dx;
1406 self->oy += dy; self->y += dy; 1961 self->oy += dy; self->y += dy;
1407 1962
1408 while (self->y < 0) 1963 while (self->y < 0)
… …
1412 self->rows += MAP_EXTEND_Y; 1967 self->rows += MAP_EXTEND_Y;
1413 self->y += MAP_EXTEND_Y; 1968 self->y += MAP_EXTEND_Y;
1414 } 1969 }
1415} 1970}
1416 1971
1417void 1972SV *
1418map1a_update (CFPlus::Map self, SV *data_, int extmap) 1973map1a_update (DC::Map self, SV *data_, int extmap)
1419 CODE: 1974 CODE:
1420{ 1975{
1421 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1976 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1422 uint8_t *data_end = (uint8_t *)SvEND (data_); 1977 uint8_t *data_end = (uint8_t *)SvEND (data_);
1423 mapcell *cell; 1978 mapcell *cell;
1424 int x, y, flags; 1979 int x, y, z, flags;
1980 AV *missing = newAV ();
1981 RETVAL = newRV_noinc ((SV *)missing);
1425 1982
1426 while (data < data_end - 1) 1983 while (data < data_end - 1)
1427 { 1984 {
1428 flags = (data [0] << 8) + data [1]; data += 2; 1985 flags = (data [0] << 8) + data [1]; data += 2;
1429 1986
… …
1449 uint8_t ext, cmd; 2006 uint8_t ext, cmd;
1450 2007
1451 do 2008 do
1452 { 2009 {
1453 ext = *data++; 2010 ext = *data++;
1454 cmd = ext & 0x3f; 2011 cmd = ext & 0x7f;
1455 2012
1456 if (cmd < 4) 2013 if (cmd < 4)
1457 cell->darkness = 255 - ext * 64 + 1; 2014 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
1458 else if (cmd == 5) // health 2015 else if (cmd == 5) // health
1459 { 2016 {
1460 cell->stat_width = 1; 2017 cell->stat_width = 1;
1461 cell->stat_hp = *data++; 2018 cell->stat_hp = *data++;
1462 } 2019 }
1463 else if (cmd == 6) // monster width 2020 else if (cmd == 6) // monster width
1464 cell->stat_width = *data++ + 1; 2021 cell->stat_width = *data++ + 1;
1465 else if (cmd == 0x47) 2022 else if (cmd == 0x47)
1466 { 2023 {
1467 if (*data == 8) 2024 if (*data == 1) cell->player = data [1];
1468 ; // decode player uuid 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);
1469 2028
1470 data += *data + 1; 2029 data += *data + 1;
1471 } 2030 }
1472 else if (cmd == 8) // cell flags 2031 else if (cmd == 8) // cell flags
1473 cell->flags = *data++; 2032 cell->flags = *data++;
… …
1480 } 2039 }
1481 else 2040 else
1482 cell->darkness = *data++ + 1; 2041 cell->darkness = *data++ + 1;
1483 } 2042 }
1484 2043
2044 for (z = 0; z <= 2; ++z)
1485 if (flags & 4) 2045 if (flags & (4 >> z))
1486 { 2046 {
1487 faceid face = (data [0] << 8) + data [1]; data += 2; 2047 faceid face = (data [0] << 8) + data [1]; data += 2;
1488 need_facenum (self, face); 2048 need_facenum (self, face);
1489 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 }
1490 } 2066 }
1491
1492 if (flags & 2)
1493 {
1494 faceid face = (data [0] << 8) + data [1]; data += 2;
1495 need_facenum (self, face);
1496 cell->tile [1] = self->face2tile [face];
1497 }
1498
1499 if (flags & 1)
1500 {
1501 faceid face = (data [0] << 8) + data [1]; data += 2;
1502 need_facenum (self, face);
1503 cell->tile [2] = self->face2tile [face];
1504 }
1505 } 2067 }
1506 else 2068 else
1507 cell->darkness = 0; 2069 CELL_CLEAR (cell);
1508 } 2070 }
1509} 2071}
2072 OUTPUT:
2073 RETVAL
1510 2074
1511SV * 2075SV *
1512mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 2076mapmap (DC::Map self, int x0, int y0, int w, int h)
1513 CODE: 2077 CODE:
1514{ 2078{
1515 int x1, x; 2079 int x1, x;
1516 int y1, y; 2080 int y1, y;
1517 int z; 2081 int z;
… …
1562} 2126}
1563 OUTPUT: 2127 OUTPUT:
1564 RETVAL 2128 RETVAL
1565 2129
1566void 2130void
1567draw (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)
1568 CODE: 2132 CODE:
1569{ 2133{
2134 int x, y, z;
2135
1570 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ()); 2136 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1571 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
1572 uint8_t smooth_max[256][256]; 2138 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1573 smooth_key skey; 2139 smooth_key skey;
1574 int x, y, z; 2140 int pl_x, pl_y;
1575 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;
1576 2146
2147 pl_tex.name = 0;
2148
1577 // thats current max. sorry. 2149 // that's current max. sorry.
1578 if (sw > 255) sw = 255; 2150 if (sw > 255) sw = 255;
1579 if (sh > 255) sh = 255; 2151 if (sh > 255) sh = 255;
1580 2152
1581 // clear key, in case of extra padding 2153 // clear key, in case of extra padding
1582 memset (&skey, 0, sizeof (skey)); 2154 memset (&skey, 0, sizeof (skey));
1583 2155
1584 glColor4ub (255, 255, 255, 255); 2156 memset (&key, 0, sizeof (key));
1585 2157 key.r = 255;
1586 glEnable (GL_BLEND); 2158 key.g = 255;
1587 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2159 key.b = 255;
1588 glEnable (GL_TEXTURE_2D); 2160 key.a = 255;
1589 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2161 key.mode = GL_QUADS;
1590 2162 key.format = GL_T2F_V3F;
1591 glBegin (GL_QUADS);
1592
1593 last_name = 0;
1594 2163
1595 mx += self->x; 2164 mx += self->x;
1596 my += self->y; 2165 my += self->y;
1597 2166
1598 // first pass: determine smooth_max 2167 // first pass: determine smooth_max
… …
1615 MAX (self->tex [cell->tile [1]].smoothlevel, 2184 MAX (self->tex [cell->tile [1]].smoothlevel,
1616 self->tex [cell->tile [2]].smoothlevel)); 2185 self->tex [cell->tile [2]].smoothlevel));
1617 } 2186 }
1618 } 2187 }
1619 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
1620 for (z = 0; z <= 2; z++) 2193 for (z = 0; z <= 2; z++)
1621 { 2194 {
1622 memset (smooth_level, 0, sizeof (smooth_level)); 2195 memset (smooth_level, 0, sizeof (smooth_level));
2196 key.texname = -1;
1623 2197
1624 for (y = 0; y < sh; y++) 2198 for (y = 0; y < sh; y++)
1625 if (0 <= y + my && y + my < self->rows) 2199 if (0 <= y + my && y + my < self->rows)
1626 { 2200 {
1627 maprow *row = self->row + (y + my); 2201 maprow *row = self->row + (y + my);
… …
1633 tileid tile = cell->tile [z]; 2207 tileid tile = cell->tile [z];
1634 2208
1635 if (tile) 2209 if (tile)
1636 { 2210 {
1637 maptex tex = self->tex [tile]; 2211 maptex tex = self->tex [tile];
1638 int px = (x + 1) * T - tex.w; 2212 int px, py;
1639 int py = (y + 1) * T - tex.h;
1640 2213
1641 // suppressing texture state switches here
1642 // is only moderately effective, but worth the extra effort
1643 if (last_name != tex.name) 2214 if (key.texname != tex.name)
1644 { 2215 {
2216 self->tex [tile].unused = 0;
2217
1645 if (!tex.name) 2218 if (!tex.name)
1646 tex = self->tex [2]; /* missing, replace by noface */ 2219 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1647 2220
1648 glEnd (); 2221 key.texname = tex.name;
1649 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2222 arr = rc_array (rc, &key);
1650 glBegin (GL_QUADS);
1651 } 2223 }
1652 2224
1653 glTexCoord2f (0 , 0 ); glVertex2f (px , py ); 2225 px = (x + 1) * T - tex.w;
1654 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h); 2226 py = (y + 1) * T - tex.h;
1655 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1656 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1657 2227
1658 if (cell->flags && z == 2) 2228 if (expect_false (cell->player == player) && expect_false (z == 2))
1659 { 2229 {
1660 if (cell->flags & 1) 2230 pl_x = px;
2231 pl_y = py;
2232 pl_tex = tex;
1661 { 2233 continue;
1662 maptex tex = self->tex [1];
1663 int px = x * T + T * 2 / 32;
1664 int py = y * T - T * 6 / 32;
1665
1666 glEnd ();
1667 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1668 glBegin (GL_QUADS);
1669
1670 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1671 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1672 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1673 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1674 }
1675 } 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);
1676 2240
1677 // update smooth hash 2241 // update smooth hash
1678 if (tex.smoothtile) 2242 if (tex.smoothtile)
1679 { 2243 {
1680 skey.tile = tex.smoothtile; 2244 skey.tile = tex.smoothtile;
… …
1683 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2247 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1684 2248
1685 // add bits to current tile and all neighbours. skey.x|y is 2249 // add bits to current tile and all neighbours. skey.x|y is
1686 // shifted +1|+1 so we always stay positive. 2250 // shifted +1|+1 so we always stay positive.
1687 2251
2252 // bits is ___n cccc CCCC bbbb
2253 // n do not draw borders&corners
2254 // c draw these corners, but...
2255 // C ... not these
2256 // b draw these borders
2257
2258 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
2259 // ┃· ·· ·┃ ━━
2260
2261 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
2262 // ·· ·· ·┏ ┓·
2263
1688 // full tile 2264 // full tile
1689 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 2265 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1690 2266
1691 // borders 2267 // borders
1692 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0031); 2268 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1693 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0092); 2269 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1694 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 2270 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1695 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 2271 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1696 2272
1697 // corners 2273 // corners
1698 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2274 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1699 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);
1700 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);
1701 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);
1702 } 2278 }
1703 } 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 }
1704 } 2301 }
1705 } 2302 }
1706 2303
2304 rc_draw (rc);
2305 rc_clear (rc);
2306
1707 // go through all smoothlevels, lowest to highest, then draw 2307 // go through all smoothlevels, lowest to highest, then draw.
1708 // this is basically counting sort 2308 // this is basically counting sort
1709 { 2309 {
1710 int w, b; 2310 int w, b;
1711 2311
2312 glEnable (GL_TEXTURE_2D);
2313 glBegin (GL_QUADS);
1712 for (w = 0; w < 256 / 32; ++w) 2314 for (w = 0; w < 256 / 32; ++w)
1713 { 2315 {
1714 uint32_t smask = smooth_level [w]; 2316 uint32_t smask = smooth_level [w];
1715 if (smask) 2317 if (smask)
1716 for (b = 0; b < 32; ++b) 2318 for (b = 0; b < 32; ++b)
… …
1723 while ((he = hv_iternext (smooth))) 2325 while ((he = hv_iternext (smooth)))
1724 { 2326 {
1725 smooth_key *skey = (smooth_key *)HeKEY (he); 2327 smooth_key *skey = (smooth_key *)HeKEY (he);
1726 IV bits = SvIVX (HeVAL (he)); 2328 IV bits = SvIVX (HeVAL (he));
1727 2329
1728 // bits is ___n cccc CCCC bbbb
1729 // n do not draw borders&corners
1730 // c draw these corners, but...
1731 // C ... not these
1732 // b draw these borders
1733
1734 if (!(bits & 0x1000) 2330 if (!(bits & 0x1000)
1735 && skey->level == level 2331 && skey->level == level
1736 && level >= smooth_max [skey->x][skey->y]) 2332 && level > smooth_max [skey->x][skey->y])
1737 { 2333 {
1738 maptex tex = self->tex [skey->tile]; 2334 maptex tex = self->tex [skey->tile];
1739 int px = (((int)skey->x) - 1) * T; 2335 int px = (((int)skey->x) - 1) * T;
1740 int py = (((int)skey->y) - 1) * T; 2336 int py = (((int)skey->y) - 1) * T;
1741 int border = bits & 15; 2337 int border = bits & 15;
1742 int corner = (bits >> 8) & ~(bits >> 4) & 15; 2338 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1743 float dx = tex.s * .0625f; // 16 images/row 2339 float dx = tex.s * .0625f; // 16 images/row
1744 float dy = tex.t * .5f ; // 2 images/column 2340 float dy = tex.t * .5f ; // 2 images/column
1745 2341
1746 // this time naively avoiding texture state changes
1747 // save gobs of state changes.
1748 if (last_name != tex.name) 2342 if (tex.name)
1749 { 2343 {
2344 // this time avoiding texture state changes
2345 // save gobs of state changes.
1750 if (!tex.name) 2346 if (key.texname != tex.name)
1751 continue; // smoothing not yet available 2347 {
2348 self->tex [skey->tile].unused = 0;
1752 2349
1753 glEnd (); 2350 glEnd ();
1754 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2351 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1755 glBegin (GL_QUADS); 2352 glBegin (GL_QUADS);
1756 } 2353 }
1757 2354
1758 if (border) 2355 if (border)
1759 { 2356 {
1760 float ox = border * dx; 2357 float ox = border * dx;
1761 2358
1762 glTexCoord2f (ox , 0.f ); glVertex2f (px , py ); 2359 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1763 glTexCoord2f (ox , dy ); glVertex2f (px , py + T); 2360 glTexCoord2f (ox , dy ); glVertex2i (px , py + T);
1764 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T); 2361 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);
1765 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py ); 2362 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );
1766 } 2363 }
1767 2364
1768 if (corner) 2365 if (corner)
1769 { 2366 {
1770 float ox = corner * dx; 2367 float ox = corner * dx;
1771 2368
1772 glTexCoord2f (ox , dy ); glVertex2f (px , py ); 2369 glTexCoord2f (ox , dy ); glVertex2i (px , py );
1773 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T); 2370 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);
1774 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T); 2371 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);
1775 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py ); 2372 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );
2373 }
1776 } 2374 }
1777 } 2375 }
1778 } 2376 }
1779 } 2377 }
1780 } 2378 }
2379
2380 glEnd ();
2381 glDisable (GL_TEXTURE_2D);
2382 key.texname = -1;
1781 } 2383 }
1782 2384
1783 hv_clear (smooth); 2385 hv_clear (smooth);
1784 } 2386 }
1785 2387
1786 glEnd (); 2388 if (pl_tex.name)
2389 {
2390 maptex tex = pl_tex;
2391 int px = pl_x + sdx;
2392 int py = pl_y + sdy;
1787 2393
1788 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
1789 glDisable (GL_BLEND); 2408 glDisable (GL_BLEND);
2409 rc_free (rc);
2410 rc_free (rc_ov);
1790 2411
1791 // top layer: overlays such as the health bar 2412 // top layer: overlays such as the health bar
1792 for (y = 0; y < sh; y++) 2413 for (y = 0; y < sh; y++)
1793 if (0 <= y + my && y + my < self->rows) 2414 if (0 <= y + my && y + my < self->rows)
1794 { 2415 {
… …
1799 { 2420 {
1800 mapcell *cell = row->col + (x + mx - row->c0); 2421 mapcell *cell = row->col + (x + mx - row->c0);
1801 2422
1802 int px = x * T; 2423 int px = x * T;
1803 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 }
1804 2431
1805 if (cell->stat_hp) 2432 if (cell->stat_hp)
1806 { 2433 {
1807 int width = cell->stat_width * T; 2434 int width = cell->stat_width * T;
1808 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2435 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
… …
1819 } 2446 }
1820 } 2447 }
1821} 2448}
1822 2449
1823void 2450void
1824draw_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)
1825 CODE: 2452 CODE:
1826{ 2453{
1827 static float color[16][3] = { 2454 static float color[16][3] = {
1828 { 0.00F, 0.00F, 0.00F }, 2455 { 0.00f, 0.00f, 0.00f },
1829 { 1.00F, 1.00F, 1.00F }, 2456 { 1.00f, 1.00f, 1.00f },
1830 { 0.00F, 0.00F, 0.55F }, 2457 { 0.00f, 0.00f, 0.55f },
1831 { 1.00F, 0.00F, 0.00F }, 2458 { 1.00f, 0.00f, 0.00f },
1832 2459
1833 { 1.00F, 0.54F, 0.00F }, 2460 { 1.00f, 0.54f, 0.00f },
1834 { 0.11F, 0.56F, 1.00F }, 2461 { 0.11f, 0.56f, 1.00f },
1835 { 0.93F, 0.46F, 0.00F }, 2462 { 0.93f, 0.46f, 0.00f },
1836 { 0.18F, 0.54F, 0.34F }, 2463 { 0.18f, 0.54f, 0.34f },
1837 2464
1838 { 0.56F, 0.73F, 0.56F }, 2465 { 0.56f, 0.73f, 0.56f },
1839 { 0.80F, 0.80F, 0.80F }, 2466 { 0.80f, 0.80f, 0.80f },
1840 { 0.55F, 0.41F, 0.13F }, 2467 { 0.55f, 0.41f, 0.13f },
1841 { 0.99F, 0.77F, 0.26F }, 2468 { 0.99f, 0.77f, 0.26f },
1842 2469
1843 { 0.74F, 0.65F, 0.41F }, 2470 { 0.74f, 0.65f, 0.41f },
1844 2471
1845 { 0.00F, 1.00F, 1.00F }, 2472 { 0.00f, 1.00f, 1.00f },
1846 { 1.00F, 0.00F, 1.00F }, 2473 { 1.00f, 0.00f, 1.00f },
1847 { 1.00F, 1.00F, 0.00F }, 2474 { 1.00f, 1.00f, 0.00f },
1848 }; 2475 };
1849 2476
1850 int x, y; 2477 int x, y;
1851 2478
1852 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 */
1853 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2486 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1854 glEnable (GL_BLEND); 2487 glEnable (GL_BLEND);
1855 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2488 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1856 glBegin (GL_QUADS); 2489 glBegin (GL_QUADS);
1857 2490
1858 for (y = 0; y < h; y++) 2491 for (y = 0; y < h; y++)
… …
1862 2495
1863 if (m) 2496 if (m)
1864 { 2497 {
1865 float *c = color [m & 15]; 2498 float *c = color [m & 15];
1866 2499
1867 float tx1 = m & 0x40 ? 0.5 : 0.; 2500 float tx1 = m & 0x40 ? 0.5f : 0.f;
1868 float tx2 = tx1 + 0.5; 2501 float tx2 = tx1 + 0.5f;
1869 2502
1870 glColor4f (c[0], c[1], c[2], 0.75); 2503 glColor4f (c[0], c[1], c[2], 1);
1871 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2504 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
1872 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2505 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
1873 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2506 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
1874 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2507 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
1875 } 2508 }
… …
1879 glDisable (GL_BLEND); 2512 glDisable (GL_BLEND);
1880 glDisable (GL_TEXTURE_2D); 2513 glDisable (GL_TEXTURE_2D);
1881} 2514}
1882 2515
1883void 2516void
1884fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh) 2517fow_texture (DC::Map self, int mx, int my, int sw, int sh)
1885 PPCODE: 2518 PPCODE:
1886{ 2519{
1887 int x, y; 2520 int x, y;
1888 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);
1889 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2526 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
1890 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2527 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1891 2528
1892 memset (darkness, 255, sw4 * sh);
1893 SvPOK_only (darkness_sv); 2529 SvPOK_only (darkness3_sv);
1894 SvCUR_set (darkness_sv, sw4 * sh); 2530 SvCUR_set (darkness3_sv, sw3 * sh3);
1895 2531
1896 mx += self->x; 2532 mx += self->x - 1;
1897 my += self->y; 2533 my += self->y - 1;
1898 2534
1899 for (y = 0; y < sh; y++) 2535 for (y = 0; y < sh1; y++)
1900 if (0 <= y + my && y + my < self->rows) 2536 if (0 <= y + my && y + my < self->rows)
1901 { 2537 {
1902 maprow *row = self->row + (y + my); 2538 maprow *row = self->row + (y + my);
1903 2539
1904 for (x = 0; x < sw; x++) 2540 for (x = 0; x < sw1; x++)
1905 if (row->c0 <= x + mx && x + mx < row->c1) 2541 if (row->c0 <= x + mx && x + mx < row->c1)
1906 { 2542 {
1907 mapcell *cell = row->col + (x + mx - row->c0); 2543 mapcell *cell = row->col + (x + mx - row->c0);
1908 2544
1909 darkness[y * sw4 + x] = cell->darkness 2545 darkness1 [y * sw1 + x] = cell->darkness
1910 ? 255 - (cell->darkness - 1) 2546 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
1911 : 255 - FOW_DARKNESS; 2547 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
1912 } 2548 }
1913 } 2549 }
1914 2550
2551 for (y = 0; y < sh; ++y)
2552 for (x = 0; x < sw; ++x)
2553 {
2554 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2555 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2556 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2557 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2558 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2559 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2560 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2561 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2562 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2563
2564 uint8_t r11 = (d11 + d21 + d12) / 3;
2565 uint8_t r21 = d21;
2566 uint8_t r31 = (d21 + d31 + d32) / 3;
2567
2568 uint8_t r12 = d12;
2569 uint8_t r22 = d22;
2570 uint8_t r32 = d32;
2571
2572 uint8_t r13 = (d13 + d23 + d12) / 3;
2573 uint8_t r23 = d23;
2574 uint8_t r33 = (d23 + d33 + d32) / 3;
2575
2576 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2577 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2578 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2579 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2580 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2581 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2582 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2583 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2584 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2585 }
2586
2587 free (darkness1);
2588
1915 EXTEND (SP, 3); 2589 EXTEND (SP, 3);
1916 PUSHs (sv_2mortal (newSViv (sw4))); 2590 PUSHs (sv_2mortal (newSViv (sw3)));
1917 PUSHs (sv_2mortal (newSViv (sh))); 2591 PUSHs (sv_2mortal (newSViv (sh3)));
1918 PUSHs (darkness_sv); 2592 PUSHs (darkness3_sv);
1919} 2593}
1920 2594
1921SV * 2595SV *
1922get_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)
1923 CODE: 2597 CODE:
1924{ 2598{
1925 int x, y, x1, y1; 2599 int x, y, x1, y1;
1926 SV *data_sv = newSV (w * h * 7 + 5); 2600 SV *data_sv = newSV (w * h * 7 + 5);
1927 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2601 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
1984 else 2658 else
1985 *data++ = 0; 2659 *data++ = 0;
1986 } 2660 }
1987 } 2661 }
1988 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 {
1989 SvPOK_only (data_sv); 2666 SvPOK_only (data_sv);
1990 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2667 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2668 }
2669
1991 RETVAL = data_sv; 2670 RETVAL = data_sv;
1992} 2671}
1993 OUTPUT: 2672 OUTPUT:
1994 RETVAL 2673 RETVAL
1995 2674
1996void 2675void
1997set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2676set_rect (DC::Map self, int x0, int y0, SV *data_sv)
1998 PPCODE: 2677 PPCODE:
1999{ 2678{
2000 int x, y, z; 2679 int x, y, z;
2001 int w, h; 2680 int w, h;
2002 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;
2003 2692
2004 if (*data++ != 0) 2693 if (*data++ != 0)
2005 return; /* version mismatch */ 2694 XSRETURN_EMPTY; /* version mismatch */
2006 2695
2007 w = *data++ << 8; w |= *data++; 2696 w = *data++ << 8; w |= *data++;
2008 h = *data++ << 8; h |= *data++; 2697 h = *data++ << 8; h |= *data++;
2009 2698
2010 // 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
… …
2022 { 2711 {
2023 maprow *row = map_get_row (self, y); 2712 maprow *row = map_get_row (self, y);
2024 2713
2025 for (x = x0; x < x1; x++) 2714 for (x = x0; x < x1; x++)
2026 { 2715 {
2716 uint8_t flags;
2717
2718 if (data + 7 >= end)
2719 XSRETURN_EMPTY;
2720
2027 uint8_t flags = *data++; 2721 flags = *data++;
2028 2722
2029 if (flags) 2723 if (flags)
2030 { 2724 {
2031 mapcell *cell = row_get_cell (row, x); 2725 mapcell *cell = row_get_cell (row, x);
2032 tileid tile[3] = { 0, 0, 0 }; 2726 tileid tile[3] = { 0, 0, 0 };
… …
2035 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2729 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2036 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2730 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2037 2731
2038 if (cell->darkness == 0) 2732 if (cell->darkness == 0)
2039 { 2733 {
2040 cell->darkness = 0; 2734 /*cell->darkness = 0;*/
2735 EXTEND (SP, 3);
2041 2736
2042 for (z = 0; z <= 2; z++) 2737 for (z = 0; z <= 2; z++)
2043 { 2738 {
2044 tileid t = tile [z]; 2739 tileid t = tile [z];
2045 2740
2046 if (t >= self->texs || (t && !self->tex [t].name)) 2741 if (t >= self->texs || (t && !self->tex [t].name))
2047 { 2742 {
2048 XPUSHs (sv_2mortal (newSViv (t))); 2743 PUSHs (sv_2mortal (newSViv (t)));
2049 need_texid (self, t); 2744 need_texid (self, t);
2050 } 2745 }
2051 2746
2052 cell->tile [z] = t; 2747 cell->tile [z] = t;
2053 } 2748 }
… …
2055 } 2750 }
2056 } 2751 }
2057 } 2752 }
2058} 2753}
2059 2754
2060MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2755MODULE = Deliantra::Client PACKAGE = DC::RW
2061 2756
2062CFPlus::MixChunk 2757DC::RW
2063new_from_file (SV *class, char *path) 2758new (SV *class, SV *data_sv)
2064 CODE: 2759 CODE:
2065 RETVAL = Mix_LoadWAV (path); 2760{
2761 STRLEN datalen;
2762 char *data = SvPVbyte (data_sv, datalen);
2763
2764 RETVAL = SDL_RWFromConstMem (data, datalen);
2765}
2066 OUTPUT: 2766 OUTPUT:
2067 RETVAL 2767 RETVAL
2068 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 : '('
2069void 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
2070DESTROY (CFPlus::MixChunk self) 2878DESTROY (DC::MixChunk self)
2071 CODE: 2879 CODE:
2072 Mix_FreeChunk (self); 2880 Mix_FreeChunk (self);
2073 2881
2074int 2882int
2075volume (CFPlus::MixChunk self, int volume = -1) 2883volume (DC::MixChunk self, int volume = -1)
2076 CODE: 2884 CODE:
2885 if (items > 1)
2886 volume = CLAMP (volume, 0, 128);
2077 RETVAL = Mix_VolumeChunk (self, volume); 2887 RETVAL = Mix_VolumeChunk (self, volume);
2078 OUTPUT: 2888 OUTPUT:
2079 RETVAL 2889 RETVAL
2080 2890
2081int 2891DC::Channel
2082play (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)
2083 CODE: 2893 CODE:
2894{
2084 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}
2085 OUTPUT: 2906 OUTPUT:
2086 RETVAL 2907 RETVAL
2087 2908
2088MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2909MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2089 2910
2090int 2911int
2091volume (int volume = -1) 2912volume (int volume = -1)
2913 PROTOTYPE: ;$
2092 CODE: 2914 CODE:
2915 if (items > 0)
2916 volume = CLAMP (volume, 0, 128);
2093 RETVAL = Mix_VolumeMusic (volume); 2917 RETVAL = Mix_VolumeMusic (volume);
2094 OUTPUT: 2918 OUTPUT:
2095 RETVAL 2919 RETVAL
2096 2920
2921void
2922fade_out (int ms)
2923 CODE:
2924 Mix_FadeOutMusic (ms);
2925
2926void
2927halt ()
2928 CODE:
2929 Mix_HaltMusic ();
2930
2097CFPlus::MixMusic 2931DC::MixMusic
2098new_from_file (SV *class, char *path) 2932new (SV *class, DC::RW rwops)
2099 CODE: 2933 CODE:
2100 RETVAL = Mix_LoadMUS (path); 2934 RETVAL = Mix_LoadMUS_RW (rwops);
2101 OUTPUT: 2935 OUTPUT:
2102 RETVAL 2936 RETVAL
2103 2937
2104void 2938void
2105DESTROY (CFPlus::MixMusic self) 2939DESTROY (DC::MixMusic self)
2106 CODE: 2940 CODE:
2107 Mix_FreeMusic (self); 2941 Mix_FreeMusic (self);
2108 2942
2109int 2943int
2110play (CFPlus::MixMusic self, int loops = -1) 2944play (DC::MixMusic self, int loops = -1)
2111 CODE: 2945 CODE:
2112 RETVAL = Mix_PlayMusic (self, loops); 2946 RETVAL = Mix_PlayMusic (self, loops);
2113 OUTPUT: 2947 OUTPUT:
2114 RETVAL 2948 RETVAL
2115 2949
2116MODULE = CFPlus PACKAGE = CFPlus::OpenGL 2950void
2951fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2952 CODE:
2953 Mix_FadeInMusicPos (self, loops, ms, position);
2954
2955MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2956
2957PROTOTYPES: ENABLE
2117 2958
2118BOOT: 2959BOOT:
2119{ 2960{
2120 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 2961 HV *stash = gv_stashpv ("DC::OpenGL", 1);
2121 static const struct { 2962 static const struct {
2122 const char *name; 2963 const char *name;
2123 IV iv; 2964 IV iv;
2124 } *civ, const_iv[] = { 2965 } *civ, const_iv[] = {
2125# define const_iv(name) { # name, (IV)name } 2966# define const_iv(name) { # name, (IV)name }
2967 const_iv (GL_VENDOR),
2968 const_iv (GL_VERSION),
2969 const_iv (GL_EXTENSIONS),
2970 const_iv (GL_MAX_TEXTURE_UNITS),
2126 const_iv (GL_COLOR_MATERIAL), 2971 const_iv (GL_COLOR_MATERIAL),
2127 const_iv (GL_SMOOTH), 2972 const_iv (GL_SMOOTH),
2128 const_iv (GL_FLAT), 2973 const_iv (GL_FLAT),
2129 const_iv (GL_DITHER), 2974 const_iv (GL_DITHER),
2130 const_iv (GL_BLEND), 2975 const_iv (GL_BLEND),
… …
2134 const_iv (GL_ALPHA_TEST), 2979 const_iv (GL_ALPHA_TEST),
2135 const_iv (GL_NORMALIZE), 2980 const_iv (GL_NORMALIZE),
2136 const_iv (GL_RESCALE_NORMAL), 2981 const_iv (GL_RESCALE_NORMAL),
2137 const_iv (GL_FRONT), 2982 const_iv (GL_FRONT),
2138 const_iv (GL_BACK), 2983 const_iv (GL_BACK),
2984 const_iv (GL_AUX0),
2139 const_iv (GL_AND), 2985 const_iv (GL_AND),
2140 const_iv (GL_ONE), 2986 const_iv (GL_ONE),
2141 const_iv (GL_ZERO), 2987 const_iv (GL_ZERO),
2142 const_iv (GL_SRC_ALPHA), 2988 const_iv (GL_SRC_ALPHA),
2143 const_iv (GL_DST_ALPHA), 2989 const_iv (GL_DST_ALPHA),
2144 const_iv (GL_ONE_MINUS_SRC_ALPHA), 2990 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2145 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),
2146 const_iv (GL_SRC_ALPHA_SATURATE), 2996 const_iv (GL_SRC_ALPHA_SATURATE),
2147 const_iv (GL_RGB), 2997 const_iv (GL_RGB),
2148 const_iv (GL_RGBA), 2998 const_iv (GL_RGBA),
2149 const_iv (GL_RGBA4), 2999 const_iv (GL_RGBA4),
2150 const_iv (GL_RGBA8), 3000 const_iv (GL_RGBA8),
… …
2156 const_iv (GL_INTENSITY), 3006 const_iv (GL_INTENSITY),
2157 const_iv (GL_LUMINANCE), 3007 const_iv (GL_LUMINANCE),
2158 const_iv (GL_LUMINANCE_ALPHA), 3008 const_iv (GL_LUMINANCE_ALPHA),
2159 const_iv (GL_FLOAT), 3009 const_iv (GL_FLOAT),
2160 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),
2161 const_iv (GL_COMPILE), 3017 const_iv (GL_COMPILE),
3018 const_iv (GL_PROXY_TEXTURE_1D),
3019 const_iv (GL_PROXY_TEXTURE_2D),
2162 const_iv (GL_TEXTURE_1D), 3020 const_iv (GL_TEXTURE_1D),
2163 const_iv (GL_TEXTURE_2D), 3021 const_iv (GL_TEXTURE_2D),
2164 const_iv (GL_TEXTURE_ENV), 3022 const_iv (GL_TEXTURE_ENV),
2165 const_iv (GL_TEXTURE_MAG_FILTER), 3023 const_iv (GL_TEXTURE_MAG_FILTER),
2166 const_iv (GL_TEXTURE_MIN_FILTER), 3024 const_iv (GL_TEXTURE_MIN_FILTER),
… …
2187 const_iv (GL_COLOR_LOGIC_OP), 3045 const_iv (GL_COLOR_LOGIC_OP),
2188 const_iv (GL_SEPARABLE_2D), 3046 const_iv (GL_SEPARABLE_2D),
2189 const_iv (GL_CONVOLUTION_2D), 3047 const_iv (GL_CONVOLUTION_2D),
2190 const_iv (GL_CONVOLUTION_BORDER_MODE), 3048 const_iv (GL_CONVOLUTION_BORDER_MODE),
2191 const_iv (GL_CONSTANT_BORDER), 3049 const_iv (GL_CONSTANT_BORDER),
3050 const_iv (GL_POINTS),
2192 const_iv (GL_LINES), 3051 const_iv (GL_LINES),
2193 const_iv (GL_LINE_STRIP), 3052 const_iv (GL_LINE_STRIP),
2194 const_iv (GL_LINE_LOOP), 3053 const_iv (GL_LINE_LOOP),
2195 const_iv (GL_QUADS), 3054 const_iv (GL_QUADS),
2196 const_iv (GL_QUAD_STRIP), 3055 const_iv (GL_QUAD_STRIP),
2197 const_iv (GL_TRIANGLES), 3056 const_iv (GL_TRIANGLES),
2198 const_iv (GL_TRIANGLE_STRIP), 3057 const_iv (GL_TRIANGLE_STRIP),
2199 const_iv (GL_TRIANGLE_FAN), 3058 const_iv (GL_TRIANGLE_FAN),
3059 const_iv (GL_POLYGON),
2200 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),
2201 const_iv (GL_FASTEST), 3066 const_iv (GL_FASTEST),
3067 const_iv (GL_DONT_CARE),
3068 const_iv (GL_NICEST),
2202 const_iv (GL_V2F), 3069 const_iv (GL_V2F),
2203 const_iv (GL_V3F), 3070 const_iv (GL_V3F),
2204 const_iv (GL_T2F_V3F), 3071 const_iv (GL_T2F_V3F),
2205 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),
2206# undef const_iv 3076# undef const_iv
2207 }; 3077 };
2208 3078
2209 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; )
2210 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3080 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
3081
3082 texture_av = newAV ();
3083 AvREAL_off (texture_av);
2211} 3084}
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)
2212 3094
2213char * 3095char *
2214gl_vendor () 3096gl_vendor ()
2215 CODE: 3097 CODE:
2216 RETVAL = (char *)glGetString (GL_VENDOR); 3098 RETVAL = (char *)glGetString (GL_VENDOR);
… …
2229 CODE: 3111 CODE:
2230 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3112 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2231 OUTPUT: 3113 OUTPUT:
2232 RETVAL 3114 RETVAL
2233 3115
3116const char *glGetString (GLenum pname)
3117
3118GLint glGetInteger (GLenum pname)
3119 CODE:
3120 glGetIntegerv (pname, &RETVAL);
3121 OUTPUT:
3122 RETVAL
3123
3124GLdouble glGetDouble (GLenum pname)
3125 CODE:
3126 glGetDoublev (pname, &RETVAL);
3127 OUTPUT:
3128 RETVAL
3129
2234int glGetError () 3130int glGetError ()
2235 3131
2236void glFinish () 3132void glFinish ()
2237 3133
2238void glClear (int mask) 3134void glClear (int mask)
… …
2252 3148
2253void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3149void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2254 CODE: 3150 CODE:
2255 gl_BlendFuncSeparate (sa, da, saa, daa); 3151 gl_BlendFuncSeparate (sa, da, saa, daa);
2256 3152
3153# void glBlendEquation (int se)
3154
2257void glDepthMask (int flag) 3155void glDepthMask (int flag)
2258 3156
2259void glLogicOp (int opcode) 3157void glLogicOp (int opcode)
2260 3158
2261void glColorMask (int red, int green, int blue, int alpha) 3159void glColorMask (int red, int green, int blue, int alpha)
… …
2275# near_ and far_ are due to microsofts buggy "c" compiler 3173# near_ and far_ are due to microsofts buggy "c" compiler
2276void 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_)
2277 3175
2278# near_ and far_ are due to microsofts buggy "c" compiler 3176# near_ and far_ are due to microsofts buggy "c" compiler
2279void 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
2280 3180
2281void glViewport (int x, int y, int width, int height) 3181void glViewport (int x, int y, int width, int height)
2282 3182
2283void glScissor (int x, int y, int width, int height) 3183void glScissor (int x, int y, int width, int height)
2284 3184
… …
2292 3192
2293void glRotate (float angle, float x, float y, float z) 3193void glRotate (float angle, float x, float y, float z)
2294 CODE: 3194 CODE:
2295 glRotatef (angle, x, y, z); 3195 glRotatef (angle, x, y, z);
2296 3196
2297void glBegin (int mode)
2298
2299void glEnd ()
2300
2301void glColor (float r, float g, float b, float a = 1.0) 3197void glColor (float r, float g, float b, float a = 1.0)
2302 PROTOTYPE: @ 3198 PROTOTYPE: @
2303 ALIAS: 3199 ALIAS:
2304 glColor_premultiply = 1 3200 glColor_premultiply = 1
2305 CODE: 3201 CODE:
2306 if (ix) 3202 if (ix)
2307 { 3203 {
… …
2310 b *= a; 3206 b *= a;
2311 } 3207 }
2312 // microsoft visual "c" rounds instead of truncating... 3208 // microsoft visual "c" rounds instead of truncating...
2313 glColor4f (r, g, b, a); 3209 glColor4f (r, g, b, a);
2314 3210
2315void glInterleavedArrays (int format, int stride, char *data)
2316
2317void glDrawElements (int mode, int count, int type, char *indices)
2318
2319# 1.2 void glDrawRangeElements (int mode, int start, int end
2320
2321void glRasterPos (float x, float y, float z = 0.) 3211void glRasterPos (float x, float y, float z = 0.)
2322 CODE: 3212 CODE:
2323 glRasterPos3f (0, 0, z); 3213 glRasterPos3f (0, 0, z);
2324 glBitmap (0, 0, 0, 0, x, y, 0); 3214 glBitmap (0, 0, 0, 0, x, y, 0);
2325 3215
… …
2329 3219
2330void glTexCoord (float s, float t) 3220void glTexCoord (float s, float t)
2331 CODE: 3221 CODE:
2332 glTexCoord2f (s, t); 3222 glTexCoord2f (s, t);
2333 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
2334void glTexEnv (int target, int pname, float param) 3253void glTexEnv (int target, int pname, float param)
2335 CODE: 3254 CODE:
2336 glTexEnvf (target, pname, param); 3255 glTexEnvf (target, pname, param);
2337 3256
2338void glTexParameter (int target, int pname, float param) 3257void glTexParameter (int target, int pname, float param)
… …
2354void 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)
2355 CODE: 3274 CODE:
2356 if (gl.SeparableFilter2D) 3275 if (gl.SeparableFilter2D)
2357 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3276 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2358 3277
2359void 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)
2360 3279
2361void 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)
2362 3281
2363void glDrawPixels (int width, int height, int format, int type, char *pixels) 3282void glDrawPixels (int width, int height, int format, int type, char *pixels)
3283
3284void glPixelZoom (float x, float y)
2364 3285
2365void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 3286void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2366 3287
2367int glGenTexture () 3288int glGenTexture ()
2368 CODE: 3289 CODE:
2369{ 3290 RETVAL = gen_texture ();
2370 GLuint name;
2371 glGenTextures (1, &name);
2372 RETVAL = name;
2373}
2374 OUTPUT: 3291 OUTPUT:
2375 RETVAL 3292 RETVAL
2376 3293
2377void glDeleteTexture (int name) 3294void glDeleteTexture (int name)
2378 CODE: 3295 CODE:
2379{
2380 GLuint name_ = name;
2381 glDeleteTextures (1, &name_); 3296 del_texture (name);
2382} 3297
2383
2384int glGenList () 3298int glGenList ()
2385 CODE: 3299 CODE:
2386 RETVAL = glGenLists (1); 3300 RETVAL = glGenLists (1);
2387 OUTPUT: 3301 OUTPUT:
2388 RETVAL 3302 RETVAL
… …
2395 3309
2396void glEndList () 3310void glEndList ()
2397 3311
2398void glCallList (int list) 3312void glCallList (int list)
2399 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