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.165 by root, Fri Dec 8 14:59:54 2006 UTC vs.
Revision 1.275 by root, Thu Aug 28 00:53:53 2008 UTC

1#ifdef _WIN32 1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN 2# define WIN32_LEAN_AND_MEAN
3# define _WIN32_WINNT 0x0500 // needed to get win2000 api calls 3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
4# include <malloc.h> 4# include <malloc.h>
5# include <windows.h> 5# include <windows.h>
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 roundf(x) (int)(x)
25# define atan2f(x,y) atan2(x,y)
26# define M_PI 3.14159265f
17#endif 27#endif
18 28
29#include <assert.h>
19#include <math.h> 30#include <math.h>
20#include <string.h> 31#include <string.h>
21#include <stdio.h> 32#include <stdio.h>
22#include <stdlib.h> 33#include <stdlib.h>
23 34
35#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36
24#include <SDL.h> 37#include <SDL.h>
38#include <SDL_thread.h>
25#include <SDL_endian.h> 39#include <SDL_endian.h>
26#include <SDL_image.h> 40#include <SDL_image.h>
27#include <SDL_mixer.h> 41#include <SDL_mixer.h>
28#include <SDL_opengl.h> 42#include <SDL_opengl.h>
29 43
44/* work around os x broken headers */
45#ifdef __MACOSX__
46typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
47#endif
48
30#define PANGO_ENABLE_BACKEND 49#define PANGO_ENABLE_BACKEND
31#define G_DISABLE_CAST_CHECKS 50#define G_DISABLE_CAST_CHECKS
32 51
33#include <glib/gmacros.h> 52#include <glib/gmacros.h>
34 53
35#include <pango/pango.h> 54#include <pango/pango.h>
55
56#ifndef PANGO_VERSION_CHECK
57# define PANGO_VERSION_CHECK(a,b,c) 0
58#endif
59
60#if !PANGO_VERSION_CHECK (1, 15, 2)
61# define pango_layout_get_line_readonly pango_layout_get_line
62# define pango_layout_get_lines_readonly pango_layout_get_lines
63# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line
64# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run
65#endif
36 66
37#ifndef _WIN32 67#ifndef _WIN32
38# include <sys/types.h> 68# include <sys/types.h>
39# include <sys/socket.h> 69# include <sys/socket.h>
40# include <netinet/in.h> 70# include <netinet/in.h>
41# include <netinet/tcp.h> 71# include <netinet/tcp.h>
42# include <inttypes.h> 72# include <inttypes.h>
43#endif 73#endif
44 74
75#if __GNUC__ >= 4
76# define expect(expr,value) __builtin_expect ((expr),(value))
77#else
78# define expect(expr,value) (expr)
79#endif
80
81#define expect_false(expr) expect ((expr) != 0, 0)
82#define expect_true(expr) expect ((expr) != 0, 1)
83
45#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 84#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
46 85
47#define FOW_DARKNESS 32 86#define FOW_DARKNESS 32
48 87
49#define MAP_EXTEND_X 32 88#define MAP_EXTEND_X 32
50#define MAP_EXTEND_Y 512 89#define MAP_EXTEND_Y 512
51 90
52#define MIN_FONT_HEIGHT 10 91#define MIN_FONT_HEIGHT 10
53 92
54#if 0 93/* mask out modifiers we are not interested in */
55# define PARACHUTE SDL_INIT_NOPARACHUTE 94#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
56#else 95
57# define PARACHUTE 0 96static AV *texture_av;
58#endif
59 97
60static struct 98static struct
61{ 99{
62#define GL_FUNC(ptr,name) ptr name; 100#define GL_FUNC(ptr,name) ptr name;
63#include "glfunc.h" 101#include "glfunc.h"
64#undef GL_FUNC 102#undef GL_FUNC
65} gl; 103} gl;
66 104
105static void
67static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa) 106gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
68{ 107{
69 if (gl.BlendFuncSeparate) 108 if (gl.BlendFuncSeparate)
70 gl.BlendFuncSeparate (sa, da, saa, daa); 109 gl.BlendFuncSeparate (sa, da, saa, daa);
71 else if (gl.BlendFuncSeparateEXT) 110 else if (gl.BlendFuncSeparateEXT)
72 gl.BlendFuncSeparateEXT (sa, da, saa, daa); 111 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
73 else 112 else
74 glBlendFunc (sa, da); 113 glBlendFunc (sa, da);
75} 114}
76 115
116static GLuint
117gen_texture ()
118{
119 GLuint name;
120
121 if (AvFILL (texture_av) >= 0)
122 name = (GLuint)(size_t)av_pop (texture_av);
123 else
124 glGenTextures (1, &name);
125
126 return name;
127}
128
129static void
130del_texture (GLuint name)
131{
132 /* make a half-assed attempt at returning the memory used by the texture */
133 /* textures are frequently being reused by cfplus anyway */
134 /*glBindTexture (GL_TEXTURE_2D, name);*/
135 /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
136 av_push (texture_av, (SV *)(size_t)name);
137 glDeleteTextures (1, &name);
138}
139
77#include "texcache.c" 140#include "texcache.c"
141#include "rendercache.c"
78 142
79#include "pango-font.c" 143#include "pango-font.c"
80#include "pango-fontmap.c" 144#include "pango-fontmap.c"
81#include "pango-render.c" 145#include "pango-render.c"
82 146
147typedef IV DC__Channel;
148typedef SDL_RWops *DC__RW;
83typedef Mix_Chunk *CFPlus__MixChunk; 149typedef Mix_Chunk *DC__MixChunk;
84typedef Mix_Music *CFPlus__MixMusic; 150typedef Mix_Music *DC__MixMusic;
85 151
86typedef PangoFontDescription *CFPlus__Font; 152typedef PangoFontDescription *DC__Font;
87 153
88static int 154static int
89shape_attr_p (PangoLayoutRun *run) 155shape_attr_p (PangoLayoutRun *run)
90{ 156{
91 GSList *attrs = run->item->analysis.extra_attrs; 157 GSList *attrs = run->item->analysis.extra_attrs;
… …
105 171
106typedef struct cf_layout { 172typedef struct cf_layout {
107 PangoLayout *pl; 173 PangoLayout *pl;
108 float r, g, b, a; // default color for rgba mode 174 float r, g, b, a; // default color for rgba mode
109 int base_height; 175 int base_height;
110 CFPlus__Font font; 176 DC__Font font;
177 rc_t *rc;
111} *CFPlus__Layout; 178} *DC__Layout;
112 179
113static CFPlus__Font default_font; 180static DC__Font default_font;
114static PangoContext *opengl_context; 181static PangoContext *opengl_context;
115static PangoFontMap *opengl_fontmap; 182static PangoFontMap *opengl_fontmap;
116 183
117static void 184static void
118substitute_func (FcPattern *pattern, gpointer data) 185substitute_func (FcPattern *pattern, gpointer data)
… …
123#endif 190#endif
124 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 191 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
125} 192}
126 193
127static void 194static void
128layout_update_font (CFPlus__Layout self) 195layout_update_font (DC__Layout self)
129{ 196{
130 /* use a random scale factor to account for unknown descenders, 0.8 works 197 /* use a random scale factor to account for unknown descenders, 0.8 works
131 * reasonably well with bitstream vera 198 * reasonably well with dejavu/bistream fonts
132 */ 199 */
133 PangoFontDescription *font = self->font ? self->font : default_font; 200 PangoFontDescription *font = self->font ? self->font : default_font;
134 201
135 pango_font_description_set_absolute_size (font, 202 pango_font_description_set_absolute_size (font,
136 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 203 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
137 204
138 pango_layout_set_font_description (self->pl, font); 205 pango_layout_set_font_description (self->pl, font);
139} 206}
140 207
141static void 208static void
142layout_get_pixel_size (CFPlus__Layout self, int *w, int *h) 209layout_get_pixel_size (DC__Layout self, int *w, int *h)
143{ 210{
144 PangoRectangle rect; 211 PangoRectangle rect;
145 212
146 // get_pixel_* wrongly rounds down 213 // get_pixel_* wrongly rounds down
147 pango_layout_get_extents (self->pl, 0, &rect); 214 pango_layout_get_extents (self->pl, 0, &rect);
… …
154 221
155 *w = rect.width; 222 *w = rect.width;
156 *h = rect.height; 223 *h = rect.height;
157} 224}
158 225
226typedef uint16_t tileid;
159typedef uint16_t mapface; 227typedef uint16_t faceid;
160 228
161typedef struct { 229typedef struct {
162 GLint name; 230 GLuint name;
163 int w, h; 231 int w, h;
164 float s, t; 232 float s, t;
165 uint8_t r, g, b, a; 233 uint8_t r, g, b, a;
234 tileid smoothtile;
235 uint8_t smoothlevel;
166} maptex; 236} maptex;
167 237
168typedef struct { 238typedef struct {
169 uint32_t player; 239 uint32_t player;
170 mapface face[3]; 240 tileid tile[3];
171 uint16_t darkness; 241 uint16_t darkness;
172 uint8_t stat_width, stat_hp, flags; 242 uint8_t stat_width, stat_hp, flags, smoothmax;
173} mapcell; 243} mapcell;
174 244
175typedef struct { 245typedef struct {
176 int32_t c0, c1; 246 int32_t c0, c1;
177 mapcell *col; 247 mapcell *col;
178} maprow; 248} maprow;
179 249
180typedef struct map { 250typedef struct map {
181 int x, y, w, h; 251 int x, y, w, h;
182 int ox, oy; /* offset to virtual global coordinate system */ 252 int ox, oy; /* offset to virtual global coordinate system */
183 int faces; 253 int faces; tileid *face2tile; // [faceid]
184 mapface *face; 254 int texs; maptex *tex; // [tileid]
185
186 int texs;
187 maptex *tex;
188 255
189 int32_t rows; 256 int32_t rows;
190 maprow *row; 257 maprow *row;
191} *CFPlus__Map; 258} *DC__Map;
192 259
193static char * 260static char *
194prepend (char *ptr, int sze, int inc) 261prepend (char *ptr, int sze, int inc)
195{ 262{
196 char *p; 263 char *p;
… …
213} 280}
214 281
215#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 282#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
216#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 283#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
217 284
285static void
286need_facenum (struct map *self, faceid face)
287{
288 while (self->faces <= face)
289 {
290 Append (tileid, self->face2tile, self->faces, self->faces);
291 self->faces *= 2;
292 }
293}
294
295static void
296need_texid (struct map *self, int texid)
297{
298 while (self->texs <= texid)
299 {
300 Append (maptex, self->tex, self->texs, self->texs);
301 self->texs *= 2;
302 }
303}
304
218static maprow * 305static maprow *
219map_get_row (CFPlus__Map self, int y) 306map_get_row (DC__Map self, int y)
220{ 307{
221 if (0 > y) 308 if (0 > y)
222 { 309 {
223 int extend = - y + MAP_EXTEND_Y; 310 int extend = - y + MAP_EXTEND_Y;
224 Prepend (maprow, self->row, self->rows, extend); 311 Prepend (maprow, self->row, self->rows, extend);
… …
262 349
263 return row->col + (x - row->c0); 350 return row->col + (x - row->c0);
264} 351}
265 352
266static mapcell * 353static mapcell *
267map_get_cell (CFPlus__Map self, int x, int y) 354map_get_cell (DC__Map self, int x, int y)
268{ 355{
269 return row_get_cell (map_get_row (self, y), x); 356 return row_get_cell (map_get_row (self, y), x);
270} 357}
271 358
272static void 359static void
273map_clear (CFPlus__Map self) 360map_clear (DC__Map self)
274{ 361{
275 int r; 362 int r;
276 363
277 for (r = 0; r < self->rows; r++) 364 for (r = 0; r < self->rows; r++)
278 Safefree (self->row[r].col); 365 Safefree (self->row[r].col);
… …
285 self->oy = 0; 372 self->oy = 0;
286 self->row = 0; 373 self->row = 0;
287 self->rows = 0; 374 self->rows = 0;
288} 375}
289 376
377#define CELL_CLEAR(cell) \
378 do { \
379 if ((cell)->player) \
380 (cell)->tile [2] = 0; \
381 (cell)->darkness = 0; \
382 (cell)->stat_hp = 0; \
383 (cell)->flags = 0; \
384 (cell)->player = 0; \
385 } while (0)
386
290static void 387static void
291map_blank (CFPlus__Map self, int x0, int y0, int w, int h) 388map_blank (DC__Map self, int x0, int y0, int w, int h)
292{ 389{
293 int x, y; 390 int x, y;
294 maprow *row; 391 maprow *row;
295 mapcell *cell; 392 mapcell *cell;
296 393
… …
308 if (x >= row->c1) 405 if (x >= row->c1)
309 break; 406 break;
310 407
311 cell = row->col + x - row->c0; 408 cell = row->col + x - row->c0;
312 409
313 cell->darkness = 0; 410 CELL_CLEAR (cell);
314 cell->stat_hp = 0;
315 cell->flags = 0;
316 cell->player = 0;
317 } 411 }
318 } 412 }
413}
414
415typedef struct {
416 tileid tile;
417 uint8_t x, y, level;
418} smooth_key;
419
420static void
421smooth_or_bits (HV *hv, smooth_key *key, IV bits)
422{
423 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
424
425 if (SvIOK (*sv))
426 SvIV_set (*sv, SvIVX (*sv) | bits);
427 else
428 sv_setiv (*sv, bits);
319} 429}
320 430
321static void 431static void
322music_finished (void) 432music_finished (void)
323{ 433{
… …
359 n |= n >> 16; 469 n |= n >> 16;
360 470
361 return n + 1; 471 return n + 1;
362} 472}
363 473
364MODULE = CFPlus PACKAGE = CFPlus 474static unsigned int
475popcount (unsigned int n)
476{
477 n -= (n >> 1) & 0x55555555U;
478 n = ((n >> 2) & 0x33333333U) + (n & 0x33333333U);
479 n = ((n >> 4) + n) & 0x0f0f0f0fU;
480 n *= 0x01010101U;
481
482 return n >> 24;
483}
484
485/* SDL should provide this, really. */
486#define SDLK_MODIFIER_MIN 300
487#define SDLK_MODIFIER_MAX 314
488
489/******************************************************************************/
490
491static GV *draw_x_gv, *draw_y_gv, *draw_w_gv, *draw_h_gv;
492static GV *hover_gv;
493
494static int
495within_widget (SV *widget, NV x, NV y)
496{
497 HV *self;
498 SV **svp;
499 NV wx, ww, wy, wh;
500
501 if (!SvROK (widget))
502 return 0;
503
504 self = (HV *)SvRV (widget);
505
506 if (SvTYPE (self) != SVt_PVHV)
507 return 0;
508
509 svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
510 if (y < wy)
511 return 0;
512
513 svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
514 if (y >= wy + wh)
515 return 0;
516
517 svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
518 if (x < wx)
519 return 0;
520
521 svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
522 if (x >= wx + ww)
523 return 0;
524
525 svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
526 if (!svp || !SvTRUE (*svp))
527 return 0;
528
529 return 1;
530}
531
532static void
533deliantra_main ()
534{
535 char *argv[] = { 0 };
536 call_argv ("::main", G_DISCARD | G_VOID, argv);
537}
538
539#ifdef __MACOSX__
540 /* to due surprising braindamage on the side of SDL design, we
541 * do some mind-boggling hack here: SDL requires a custom main()
542 * on OS X, so... we provide one and call the original main(), which,
543 * due to share dlibrary magic, calls -lSDLmain's main, not perl's main,
544 * and which calls our main (== SDL_main) back.
545 */
546 extern C_LINKAGE int
547 main (int argc, char *argv[])
548 {
549 deliantra_main ();
550 }
551
552 #undef main
553
554 extern C_LINKAGE int main (int argc, char *argv[]);
555
556 static void
557 SDL_braino (void)
558 {
559 char *argv[] = { "deliantra client", 0 };
560 (main) (1, argv);
561 }
562#else
563 static void
564 SDL_braino (void)
565 {
566 deliantra_main ();
567 }
568#endif
569
570MODULE = Deliantra::Client PACKAGE = DC
365 571
366PROTOTYPES: ENABLE 572PROTOTYPES: ENABLE
367 573
368BOOT: 574BOOT:
369{ 575{
370 HV *stash = gv_stashpv ("CFPlus", 1); 576 HV *stash = gv_stashpv ("DC", 1);
371 static const struct { 577 static const struct {
372 const char *name; 578 const char *name;
373 IV iv; 579 IV iv;
374 } *civ, const_iv[] = { 580 } *civ, const_iv[] = {
375# define const_iv(name) { # name, (IV)name } 581# define const_iv(name) { # name, (IV)name }
582 const_iv (SDLK_MODIFIER_MIN),
583 const_iv (SDLK_MODIFIER_MAX),
584
376 const_iv (SDL_ACTIVEEVENT), 585 const_iv (SDL_ACTIVEEVENT),
377 const_iv (SDL_KEYDOWN), 586 const_iv (SDL_KEYDOWN),
378 const_iv (SDL_KEYUP), 587 const_iv (SDL_KEYUP),
379 const_iv (SDL_MOUSEMOTION), 588 const_iv (SDL_MOUSEMOTION),
380 const_iv (SDL_MOUSEBUTTONDOWN), 589 const_iv (SDL_MOUSEBUTTONDOWN),
… …
389 const_iv (SDL_EVENT_RESERVEDA), 598 const_iv (SDL_EVENT_RESERVEDA),
390 const_iv (SDL_EVENT_RESERVEDB), 599 const_iv (SDL_EVENT_RESERVEDB),
391 const_iv (SDL_VIDEORESIZE), 600 const_iv (SDL_VIDEORESIZE),
392 const_iv (SDL_VIDEOEXPOSE), 601 const_iv (SDL_VIDEOEXPOSE),
393 const_iv (SDL_USEREVENT), 602 const_iv (SDL_USEREVENT),
603
604 const_iv (SDL_APPINPUTFOCUS),
605 const_iv (SDL_APPMOUSEFOCUS),
606 const_iv (SDL_APPACTIVE),
607
608
609 const_iv (SDLK_UNKNOWN),
610 const_iv (SDLK_FIRST),
611 const_iv (SDLK_BACKSPACE),
612 const_iv (SDLK_TAB),
613 const_iv (SDLK_CLEAR),
614 const_iv (SDLK_RETURN),
615 const_iv (SDLK_PAUSE),
616 const_iv (SDLK_ESCAPE),
617 const_iv (SDLK_SPACE),
618 const_iv (SDLK_EXCLAIM),
619 const_iv (SDLK_QUOTEDBL),
620 const_iv (SDLK_HASH),
621 const_iv (SDLK_DOLLAR),
622 const_iv (SDLK_AMPERSAND),
623 const_iv (SDLK_QUOTE),
624 const_iv (SDLK_LEFTPAREN),
625 const_iv (SDLK_RIGHTPAREN),
626 const_iv (SDLK_ASTERISK),
627 const_iv (SDLK_PLUS),
628 const_iv (SDLK_COMMA),
629 const_iv (SDLK_MINUS),
630 const_iv (SDLK_PERIOD),
631 const_iv (SDLK_SLASH),
632 const_iv (SDLK_0),
633 const_iv (SDLK_1),
634 const_iv (SDLK_2),
635 const_iv (SDLK_3),
636 const_iv (SDLK_4),
637 const_iv (SDLK_5),
638 const_iv (SDLK_6),
639 const_iv (SDLK_7),
640 const_iv (SDLK_8),
641 const_iv (SDLK_9),
642 const_iv (SDLK_COLON),
643 const_iv (SDLK_SEMICOLON),
644 const_iv (SDLK_LESS),
645 const_iv (SDLK_EQUALS),
646 const_iv (SDLK_GREATER),
647 const_iv (SDLK_QUESTION),
648 const_iv (SDLK_AT),
649
650 const_iv (SDLK_LEFTBRACKET),
651 const_iv (SDLK_BACKSLASH),
652 const_iv (SDLK_RIGHTBRACKET),
653 const_iv (SDLK_CARET),
654 const_iv (SDLK_UNDERSCORE),
655 const_iv (SDLK_BACKQUOTE),
656 const_iv (SDLK_DELETE),
657
658 const_iv (SDLK_FIRST),
659 const_iv (SDLK_LAST),
394 const_iv (SDLK_KP0), 660 const_iv (SDLK_KP0),
395 const_iv (SDLK_KP1), 661 const_iv (SDLK_KP1),
396 const_iv (SDLK_KP2), 662 const_iv (SDLK_KP2),
397 const_iv (SDLK_KP3), 663 const_iv (SDLK_KP3),
398 const_iv (SDLK_KP4), 664 const_iv (SDLK_KP4),
… …
453 const_iv (SDLK_BREAK), 719 const_iv (SDLK_BREAK),
454 const_iv (SDLK_MENU), 720 const_iv (SDLK_MENU),
455 const_iv (SDLK_POWER), 721 const_iv (SDLK_POWER),
456 const_iv (SDLK_EURO), 722 const_iv (SDLK_EURO),
457 const_iv (SDLK_UNDO), 723 const_iv (SDLK_UNDO),
724
458 const_iv (KMOD_NONE), 725 const_iv (KMOD_NONE),
726 const_iv (KMOD_SHIFT),
459 const_iv (KMOD_LSHIFT), 727 const_iv (KMOD_LSHIFT),
460 const_iv (KMOD_RSHIFT), 728 const_iv (KMOD_RSHIFT),
729 const_iv (KMOD_CTRL),
461 const_iv (KMOD_LCTRL), 730 const_iv (KMOD_LCTRL),
462 const_iv (KMOD_RCTRL), 731 const_iv (KMOD_RCTRL),
732 const_iv (KMOD_ALT),
463 const_iv (KMOD_LALT), 733 const_iv (KMOD_LALT),
464 const_iv (KMOD_RALT), 734 const_iv (KMOD_RALT),
735 const_iv (KMOD_META),
465 const_iv (KMOD_LMETA), 736 const_iv (KMOD_LMETA),
466 const_iv (KMOD_RMETA), 737 const_iv (KMOD_RMETA),
467 const_iv (KMOD_NUM), 738 const_iv (KMOD_NUM),
468 const_iv (KMOD_CAPS), 739 const_iv (KMOD_CAPS),
469 const_iv (KMOD_MODE), 740 const_iv (KMOD_MODE),
470 const_iv (KMOD_CTRL), 741
471 const_iv (KMOD_SHIFT), 742 const_iv (MIX_DEFAULT_FORMAT),
472 const_iv (KMOD_ALT), 743
473 const_iv (KMOD_META) 744 const_iv (SDL_INIT_TIMER),
745 const_iv (SDL_INIT_AUDIO),
746 const_iv (SDL_INIT_VIDEO),
747 const_iv (SDL_INIT_CDROM),
748 const_iv (SDL_INIT_JOYSTICK),
749 const_iv (SDL_INIT_EVERYTHING),
750 const_iv (SDL_INIT_NOPARACHUTE),
751 const_iv (SDL_INIT_EVENTTHREAD),
752
753 const_iv (SDL_GL_RED_SIZE),
754 const_iv (SDL_GL_GREEN_SIZE),
755 const_iv (SDL_GL_BLUE_SIZE),
756 const_iv (SDL_GL_ALPHA_SIZE),
757 const_iv (SDL_GL_DOUBLEBUFFER),
758 const_iv (SDL_GL_BUFFER_SIZE),
759 const_iv (SDL_GL_DEPTH_SIZE),
760 const_iv (SDL_GL_STENCIL_SIZE),
761 const_iv (SDL_GL_ACCUM_RED_SIZE),
762 const_iv (SDL_GL_ACCUM_GREEN_SIZE),
763 const_iv (SDL_GL_ACCUM_BLUE_SIZE),
764 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
765 const_iv (SDL_GL_STEREO),
766 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
767 const_iv (SDL_GL_MULTISAMPLESAMPLES),
768 const_iv (SDL_GL_ACCELERATED_VISUAL),
769 const_iv (SDL_GL_SWAP_CONTROL),
770
771 const_iv (FOW_DARKNESS)
474# undef const_iv 772# undef const_iv
475 }; 773 };
476 774
477 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 775 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
478 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 776 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
777
778 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
779 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
479} 780}
781
782void
783weaken (SV *rv)
784 PROTOTYPE: $
785 CODE:
786 sv_rvweaken (rv);
480 787
481int 788int
482in_destruct () 789in_destruct ()
483 CODE: 790 CODE:
484 RETVAL = PL_main_cv == Nullcv; 791 RETVAL = PL_main_cv == Nullcv;
… …
487 794
488NV floor (NV x) 795NV floor (NV x)
489 796
490NV ceil (NV x) 797NV ceil (NV x)
491 798
799IV minpot (UV n)
800
801IV popcount (UV n)
802
492void 803void
493pango_init () 804pango_init ()
494 CODE: 805 CODE:
495{ 806{
496 opengl_fontmap = pango_opengl_font_map_new (); 807 opengl_fontmap = pango_opengl_font_map_new ();
497 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 808 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
498 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 809 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
810 /*pango_context_set_font_description (opengl_context, default_font);*/
811#if PANGO_VERSION_CHECK (1, 15, 2)
812 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
813 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
814#endif
499} 815}
500 816
501int 817char *SDL_GetError ()
502SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
503 818
504void 819void SDL_braino ()
820
821int SDL_Init (U32 flags)
822
823int SDL_InitSubSystem (U32 flags)
824
825void SDL_QuitSubSystem (U32 flags)
826
505SDL_Quit () 827void SDL_Quit ()
506 828
829int SDL_GL_SetAttribute (int attr, int value)
830
831int SDL_GL_GetAttribute (int attr)
832 CODE:
833 if (SDL_GL_GetAttribute (attr, &RETVAL))
834 XSRETURN_UNDEF;
835 OUTPUT:
836 RETVAL
837
507void 838void
508SDL_ListModes () 839SDL_ListModes (int rgb, int alpha)
509 PPCODE: 840 PPCODE:
510{ 841{
511 SDL_Rect **m; 842 SDL_Rect **m;
512 843
513 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 844 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
514 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 845 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
515 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 846 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
516 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 847 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
517 848
518 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 849 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
519 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 850 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
520 851
521 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 852 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
522 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 853 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
523 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 854 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
524 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 855 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
525 856
526 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 857 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
527#if SDL_VERSION_ATLEAST(1,2,10)
528 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
529 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 858 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
530#endif
531
532 SDL_EnableUNICODE (1);
533 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
534 859
535 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 860 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
536 861
537 if (m && m != (SDL_Rect **)-1) 862 if (m && m != (SDL_Rect **)-1)
538 while (*m) 863 while (*m)
539 { 864 {
865 if ((*m)->w >= 400 && (*m)->h >= 300)
866 {
540 AV *av = newAV (); 867 AV *av = newAV ();
541 av_push (av, newSViv ((*m)->w)); 868 av_push (av, newSViv ((*m)->w));
542 av_push (av, newSViv ((*m)->h)); 869 av_push (av, newSViv ((*m)->h));
870 av_push (av, newSViv (rgb));
871 av_push (av, newSViv (alpha));
543 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 872 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
873 }
544 874
545 ++m; 875 ++m;
546 } 876 }
547} 877}
548 878
549char *
550SDL_GetError ()
551
552int 879int
553SDL_SetVideoMode (int w, int h, int fullscreen) 880SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
554 CODE: 881 CODE:
882{
883 SDL_EnableUNICODE (1);
884 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
885
886 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
887 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
888 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
889 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
890
555 RETVAL = !!SDL_SetVideoMode ( 891 RETVAL = !!SDL_SetVideoMode (
556 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 892 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
557 ); 893 );
894
558 if (RETVAL) 895 if (RETVAL)
559 { 896 {
560 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 897 av_clear (texture_av);
898
899 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
561# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 900#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
562# include "glfunc.h" 901#include "glfunc.h"
563# undef GL_FUNC 902#undef GL_FUNC
564 } 903 }
904}
565 OUTPUT: 905 OUTPUT:
566 RETVAL 906 RETVAL
567 907
568void 908void
569SDL_GL_SwapBuffers () 909SDL_GL_SwapBuffers ()
570 910
571char * 911char *
572SDL_GetKeyName (int sym) 912SDL_GetKeyName (int sym)
573 913
914int
915SDL_GetAppState ()
916
917int
918SDL_GetModState ()
919
574void 920void
575SDL_PollEvent () 921poll_events ()
576 PPCODE: 922 PPCODE:
577{ 923{
578 SDL_Event ev; 924 SDL_Event ev;
579 925
580 while (SDL_PollEvent (&ev)) 926 SDL_PumpEvents ();
927 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
581 { 928 {
582 HV *hv = newHV (); 929 HV *hv = newHV ();
583 hv_store (hv, "type", 4, newSViv (ev.type), 0); 930 hv_store (hv, "type", 4, newSViv (ev.type), 0);
584 931
585 switch (ev.type) 932 switch (ev.type)
586 { 933 {
587 case SDL_KEYDOWN: 934 case SDL_KEYDOWN:
588 case SDL_KEYUP: 935 case SDL_KEYUP:
589 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 936 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
590 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 937 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
591 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 938 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod & MOD_MASK), 0);
939 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState () & MOD_MASK), 0); /* current mode */
592 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 940 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
593 break; 941 break;
594 942
595 case SDL_ACTIVEEVENT: 943 case SDL_ACTIVEEVENT:
596 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 944 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
597 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 945 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
598 break; 946 break;
599 947
600 case SDL_MOUSEMOTION: 948 case SDL_MOUSEMOTION:
949 {
950 int state = ev.motion.state;
951 int x = ev.motion.x;
952 int y = ev.motion.y;
953 int xrel = ev.motion.xrel;
954 int yrel = ev.motion.yrel;
955
956 /* do simplistic event compression */
957 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
958 && state == ev.motion.state)
959 {
960 xrel += ev.motion.xrel;
961 yrel += ev.motion.yrel;
962 x = ev.motion.x;
963 y = ev.motion.y;
964 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
965 }
966
601 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 967 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
602
603 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 968 hv_store (hv, "state", 5, newSViv (state), 0);
604 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 969 hv_store (hv, "x", 1, newSViv (x), 0);
605 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 970 hv_store (hv, "y", 1, newSViv (y), 0);
606 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 971 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
607 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 972 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
973 }
608 break; 974 break;
609 975
610 case SDL_MOUSEBUTTONDOWN: 976 case SDL_MOUSEBUTTONDOWN:
611 case SDL_MOUSEBUTTONUP: 977 case SDL_MOUSEBUTTONUP:
612 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 978 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
613 979
614 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 980 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
615 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 981 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
616 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 982 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
617 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 983 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
… …
622 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 988 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
623 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 989 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
624 break; 990 break;
625 } 991 }
626 992
627 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1)))); 993 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
628 } 994 }
629} 995}
630 996
631int 997int
632Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048) 998Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
633 POSTCALL: 999 POSTCALL:
634 Mix_HookMusicFinished (music_finished); 1000 Mix_HookMusicFinished (music_finished);
635 Mix_ChannelFinished (channel_finished); 1001 Mix_ChannelFinished (channel_finished);
636 1002
637void 1003void
1004Mix_QuerySpec ()
1005 PPCODE:
1006{
1007 int freq, channels;
1008 Uint16 format;
1009
1010 if (Mix_QuerySpec (&freq, &format, &channels))
1011 {
1012 EXTEND (SP, 3);
1013 PUSHs (sv_2mortal (newSViv (freq)));
1014 PUSHs (sv_2mortal (newSViv (format)));
1015 PUSHs (sv_2mortal (newSViv (channels)));
1016 }
1017}
1018
1019void
638Mix_CloseAudio () 1020Mix_CloseAudio ()
639 1021
640int 1022int
641Mix_AllocateChannels (int numchans = -1) 1023Mix_AllocateChannels (int numchans = -1)
642 1024
1025const char *
1026Mix_GetError ()
1027
643void 1028void
644lowdelay (int fd, int val = 1) 1029lowdelay (int fd, int val = 1)
645 CODE: 1030 CODE:
646#ifndef _WIN32
647 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 1031 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
648#endif
649 1032
650void 1033void
651win32_proxy_info () 1034win32_proxy_info ()
652 PPCODE: 1035 PPCODE:
653{ 1036{
… …
674 } 1057 }
675 } 1058 }
676#endif 1059#endif
677} 1060}
678 1061
679void 1062int
680add_font (char *file) 1063add_font (char *file)
681 CODE: 1064 CODE:
682 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1065 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1066 OUTPUT:
1067 RETVAL
683 1068
684void 1069void
685load_image_inline (SV *image_) 1070load_image_inline (SV *image_)
686 ALIAS: 1071 ALIAS:
687 load_image_file = 1 1072 load_image_file = 1
… …
690 STRLEN image_len; 1075 STRLEN image_len;
691 char *image = (char *)SvPVbyte (image_, image_len); 1076 char *image = (char *)SvPVbyte (image_, image_len);
692 SDL_Surface *surface, *surface2; 1077 SDL_Surface *surface, *surface2;
693 SDL_PixelFormat fmt; 1078 SDL_PixelFormat fmt;
694 SDL_RWops *rw = ix 1079 SDL_RWops *rw = ix
695 ? SDL_RWFromFile (image, "r") 1080 ? SDL_RWFromFile (image, "rb")
696 : SDL_RWFromConstMem (image, image_len); 1081 : SDL_RWFromConstMem (image, image_len);
697 1082
698 if (!rw) 1083 if (!rw)
699 croak ("load_image: %s", SDL_GetError ()); 1084 croak ("load_image: %s", SDL_GetError ());
700 1085
… …
773void 1158void
774error (char *message) 1159error (char *message)
775 CODE: 1160 CODE:
776 fprintf (stderr, "ERROR: %s\n", message); 1161 fprintf (stderr, "ERROR: %s\n", message);
777#ifdef _WIN32 1162#ifdef _WIN32
778 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR); 1163 MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
779#endif 1164#endif
780 1165
781void 1166void
782fatal (char *message) 1167fatal (char *message)
783 CODE: 1168 CODE:
784 fprintf (stderr, "FATAL: %s\n", message); 1169 fprintf (stderr, "FATAL: %s\n", message);
785#ifdef _WIN32 1170#ifdef _WIN32
786 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 1171 MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
787#endif 1172#endif
788 _exit (1); 1173 _exit (1);
789 1174
790void 1175void
791_exit (int retval = 0) 1176_exit (int retval = 0)
… …
794 ExitThread (retval); // unclean, please beam me up 1179 ExitThread (retval); // unclean, please beam me up
795#else 1180#else
796 _exit (retval); 1181 _exit (retval);
797#endif 1182#endif
798 1183
799MODULE = CFPlus PACKAGE = CFPlus::Font 1184void
1185debug ()
1186 CODE:
1187{
1188#if DEBUG
1189 VALGRIND_DO_LEAK_CHECK;
1190#endif
1191}
800 1192
801CFPlus::Font 1193MODULE = Deliantra::Client PACKAGE = DC::Font
1194
1195PROTOTYPES: DISABLE
1196
1197DC::Font
802new_from_file (SV *class, char *path, int id = 0) 1198new_from_file (SV *class, char *path, int id = 0)
803 CODE: 1199 CODE:
804{ 1200{
805 int count; 1201 int count;
806 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1202 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
… …
809} 1205}
810 OUTPUT: 1206 OUTPUT:
811 RETVAL 1207 RETVAL
812 1208
813void 1209void
814DESTROY (CFPlus::Font self) 1210DESTROY (DC::Font self)
815 CODE: 1211 CODE:
816 pango_font_description_free (self); 1212 pango_font_description_free (self);
817 1213
818void 1214void
819make_default (CFPlus::Font self) 1215make_default (DC::Font self)
1216 PROTOTYPE: $
820 CODE: 1217 CODE:
821 default_font = self; 1218 default_font = self;
822 1219
823MODULE = CFPlus PACKAGE = CFPlus::Layout 1220MODULE = Deliantra::Client PACKAGE = DC::Layout
824 1221
1222PROTOTYPES: DISABLE
1223
825void 1224void
826reset_glyph_cache () 1225glyph_cache_backup ()
1226 PROTOTYPE:
827 CODE: 1227 CODE:
1228 tc_backup ();
1229
1230void
1231glyph_cache_restore ()
1232 PROTOTYPE:
1233 CODE:
828 tc_clear (); 1234 tc_restore ();
829 1235
830CFPlus::Layout 1236DC::Layout
831new (SV *class) 1237new (SV *class)
832 CODE: 1238 CODE:
833 New (0, RETVAL, 1, struct cf_layout); 1239 New (0, RETVAL, 1, struct cf_layout);
834 1240
835 RETVAL->pl = pango_layout_new (opengl_context); 1241 RETVAL->pl = pango_layout_new (opengl_context);
… …
837 RETVAL->g = 1.; 1243 RETVAL->g = 1.;
838 RETVAL->b = 1.; 1244 RETVAL->b = 1.;
839 RETVAL->a = 1.; 1245 RETVAL->a = 1.;
840 RETVAL->base_height = MIN_FONT_HEIGHT; 1246 RETVAL->base_height = MIN_FONT_HEIGHT;
841 RETVAL->font = 0; 1247 RETVAL->font = 0;
1248 RETVAL->rc = rc_alloc ();
842 1249
843 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1250 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
844 layout_update_font (RETVAL); 1251 layout_update_font (RETVAL);
845 OUTPUT: 1252 OUTPUT:
846 RETVAL 1253 RETVAL
847 1254
848void 1255void
849DESTROY (CFPlus::Layout self) 1256DESTROY (DC::Layout self)
850 CODE: 1257 CODE:
851 g_object_unref (self->pl); 1258 g_object_unref (self->pl);
1259 rc_free (self->rc);
852 Safefree (self); 1260 Safefree (self);
853 1261
854void 1262void
855set_text (CFPlus::Layout self, SV *text_) 1263set_text (DC::Layout self, SV *text_)
856 CODE: 1264 CODE:
857{ 1265{
858 STRLEN textlen; 1266 STRLEN textlen;
859 char *text = SvPVutf8 (text_, textlen); 1267 char *text = SvPVutf8 (text_, textlen);
860 1268
861 pango_layout_set_text (self->pl, text, textlen); 1269 pango_layout_set_text (self->pl, text, textlen);
862} 1270}
863 1271
864void 1272void
865set_markup (CFPlus::Layout self, SV *text_) 1273set_markup (DC::Layout self, SV *text_)
866 CODE: 1274 CODE:
867{ 1275{
868 STRLEN textlen; 1276 STRLEN textlen;
869 char *text = SvPVutf8 (text_, textlen); 1277 char *text = SvPVutf8 (text_, textlen);
870 1278
871 pango_layout_set_markup (self->pl, text, textlen); 1279 pango_layout_set_markup (self->pl, text, textlen);
872} 1280}
873 1281
874void 1282void
875set_shapes (CFPlus::Layout self, ...) 1283set_shapes (DC::Layout self, ...)
876 CODE: 1284 CODE:
877{ 1285{
878 PangoAttrList *attrs = 0; 1286 PangoAttrList *attrs = 0;
879 const char *text = pango_layout_get_text (self->pl); 1287 const char *text = pango_layout_get_text (self->pl);
880 const char *pos = text; 1288 const char *pos = text;
… …
915 if (attrs) 1323 if (attrs)
916 pango_layout_set_attributes (self->pl, attrs); 1324 pango_layout_set_attributes (self->pl, attrs);
917} 1325}
918 1326
919void 1327void
920get_shapes (CFPlus::Layout self) 1328get_shapes (DC::Layout self)
921 PPCODE: 1329 PPCODE:
922{ 1330{
923 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1331 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
924 1332
925 do 1333 do
926 { 1334 {
927 PangoLayoutRun *run = pango_layout_iter_get_run (iter); 1335 PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
928 1336
929 if (run && shape_attr_p (run)) 1337 if (run && shape_attr_p (run))
930 { 1338 {
931 PangoRectangle extents; 1339 PangoRectangle extents;
932 pango_layout_iter_get_run_extents (iter, 0, &extents); 1340 pango_layout_iter_get_run_extents (iter, 0, &extents);
… …
940 1348
941 pango_layout_iter_free (iter); 1349 pango_layout_iter_free (iter);
942} 1350}
943 1351
944int 1352int
945has_wrapped (CFPlus::Layout self) 1353has_wrapped (DC::Layout self)
946 CODE: 1354 CODE:
947{ 1355{
948 int lines = 1; 1356 int lines = 1;
949 const char *text = pango_layout_get_text (self->pl); 1357 const char *text = pango_layout_get_text (self->pl);
950 1358
… …
955} 1363}
956 OUTPUT: 1364 OUTPUT:
957 RETVAL 1365 RETVAL
958 1366
959SV * 1367SV *
960get_text (CFPlus::Layout self) 1368get_text (DC::Layout self)
961 CODE: 1369 CODE:
962 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1370 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
963 sv_utf8_decode (RETVAL); 1371 sv_utf8_decode (RETVAL);
964 OUTPUT: 1372 OUTPUT:
965 RETVAL 1373 RETVAL
966 1374
967void 1375void
968set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.) 1376set_foreground (DC::Layout self, float r, float g, float b, float a = 1.)
969 CODE: 1377 CODE:
970 self->r = r; 1378 self->r = r;
971 self->g = g; 1379 self->g = g;
972 self->b = b; 1380 self->b = b;
973 self->a = a; 1381 self->a = a;
974 1382
975void 1383void
976set_font (CFPlus::Layout self, CFPlus::Font font = 0) 1384set_font (DC::Layout self, DC::Font font = 0)
977 CODE: 1385 CODE:
978 if (self->font != font) 1386 if (self->font != font)
979 { 1387 {
980 self->font = font; 1388 self->font = font;
981 layout_update_font (self); 1389 layout_update_font (self);
982 } 1390 }
983 1391
984void 1392void
985set_height (CFPlus::Layout self, int base_height) 1393set_height (DC::Layout self, int base_height)
986 CODE: 1394 CODE:
987 if (self->base_height != base_height) 1395 if (self->base_height != base_height)
988 { 1396 {
989 self->base_height = base_height; 1397 self->base_height = base_height;
990 layout_update_font (self); 1398 layout_update_font (self);
991 } 1399 }
992 1400
993void 1401void
994set_width (CFPlus::Layout self, int max_width = -1) 1402set_width (DC::Layout self, int max_width = -1)
995 CODE: 1403 CODE:
996 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1404 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
997 1405
998void 1406void
999set_indent (CFPlus::Layout self, int indent) 1407set_indent (DC::Layout self, int indent)
1000 CODE: 1408 CODE:
1001 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1409 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1002 1410
1003void 1411void
1004set_spacing (CFPlus::Layout self, int spacing) 1412set_spacing (DC::Layout self, int spacing)
1005 CODE: 1413 CODE:
1006 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1414 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1007 1415
1008void 1416void
1009set_ellipsise (CFPlus::Layout self, int ellipsise) 1417set_ellipsise (DC::Layout self, int ellipsise)
1010 CODE: 1418 CODE:
1011 pango_layout_set_ellipsize (self->pl, 1419 pango_layout_set_ellipsize (self->pl,
1012 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1420 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1013 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1421 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1014 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1422 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1015 : PANGO_ELLIPSIZE_NONE 1423 : PANGO_ELLIPSIZE_NONE
1016 ); 1424 );
1017 1425
1018void 1426void
1019set_single_paragraph_mode (CFPlus::Layout self, int spm) 1427set_single_paragraph_mode (DC::Layout self, int spm)
1020 CODE: 1428 CODE:
1021 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1429 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1022 1430
1023void 1431void
1024size (CFPlus::Layout self) 1432size (DC::Layout self)
1025 PPCODE: 1433 PPCODE:
1026{ 1434{
1027 int w, h; 1435 int w, h;
1028 1436
1029 layout_get_pixel_size (self, &w, &h); 1437 layout_get_pixel_size (self, &w, &h);
… …
1032 PUSHs (sv_2mortal (newSViv (w))); 1440 PUSHs (sv_2mortal (newSViv (w)));
1033 PUSHs (sv_2mortal (newSViv (h))); 1441 PUSHs (sv_2mortal (newSViv (h)));
1034} 1442}
1035 1443
1036int 1444int
1037descent (CFPlus::Layout self) 1445descent (DC::Layout self)
1038 CODE: 1446 CODE:
1039{ 1447{
1040 PangoRectangle rect; 1448 PangoRectangle rect;
1041 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1449 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1042 pango_layout_line_get_pixel_extents (line, 0, &rect); 1450 pango_layout_line_get_pixel_extents (line, 0, &rect);
1043 RETVAL = PANGO_DESCENT (rect); 1451 RETVAL = PANGO_DESCENT (rect);
1044} 1452}
1045 OUTPUT: 1453 OUTPUT:
1046 RETVAL 1454 RETVAL
1047 1455
1048int 1456int
1049xy_to_index (CFPlus::Layout self, int x, int y) 1457xy_to_index (DC::Layout self, int x, int y)
1050 CODE: 1458 CODE:
1051{ 1459{
1052 int index, trailing; 1460 int index, trailing;
1053 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1461 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1054 RETVAL = index + trailing; 1462 RETVAL = index + trailing;
1055} 1463}
1056 OUTPUT: 1464 OUTPUT:
1057 RETVAL 1465 RETVAL
1058 1466
1059void 1467void
1060cursor_pos (CFPlus::Layout self, int index) 1468cursor_pos (DC::Layout self, int index)
1061 PPCODE: 1469 PPCODE:
1062{ 1470{
1063 PangoRectangle strong_pos; 1471 PangoRectangle pos;
1064 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1472 pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1065 1473
1066 EXTEND (SP, 3); 1474 EXTEND (SP, 3);
1067 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1475 PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1068 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1476 PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1069 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1477 PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1070} 1478}
1071 1479
1072void 1480void
1073index_to_line_x (CFPlus::Layout self, int index, int trailing = 0) 1481index_to_line_x (DC::Layout self, int index, int trailing = 0)
1074 PPCODE: 1482 PPCODE:
1075{ 1483{
1076 int line, x; 1484 int line, x;
1077 1485
1078 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x); 1486 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1487#if !PANGO_VERSION_CHECK (1, 17, 3)
1079 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1488 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1080 1489 --line;
1490#endif
1081 EXTEND (SP, 2); 1491 EXTEND (SP, 2);
1082 PUSHs (sv_2mortal (newSViv (line - 1))); 1492 PUSHs (sv_2mortal (newSViv (line)));
1083 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE))); 1493 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1084} 1494}
1085 1495
1086void 1496void
1087line_x_to_index (CFPlus::Layout self, int line, int x) 1497line_x_to_index (DC::Layout self, int line, int x)
1088 PPCODE: 1498 PPCODE:
1089{ 1499{
1090 PangoLayoutLine *lp; 1500 PangoLayoutLine *lp;
1091 int index, trailing; 1501 int index, trailing;
1092 1502
1093 if (line < 0) 1503 if (line < 0)
1094 XSRETURN_EMPTY; 1504 XSRETURN_EMPTY;
1095 1505
1096 if (!(lp = pango_layout_get_line (self->pl, line))) 1506 if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1097 XSRETURN_EMPTY; /* do better */ 1507 XSRETURN_EMPTY; /* do better */
1098 1508
1099 if (!pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing)) 1509 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1100 XSRETURN_EMPTY; /* do better */
1101 1510
1102 EXTEND (SP, 2); 1511 EXTEND (SP, 2);
1103 if (GIMME_V == G_SCALAR) 1512 if (GIMME_V == G_SCALAR)
1104 PUSHs (sv_2mortal (newSViv (index + trailing))); 1513 PUSHs (sv_2mortal (newSViv (index + trailing)));
1105 else 1514 else
… …
1108 PUSHs (sv_2mortal (newSViv (trailing))); 1517 PUSHs (sv_2mortal (newSViv (trailing)));
1109 } 1518 }
1110} 1519}
1111 1520
1112void 1521void
1113render (CFPlus::Layout self, float x, float y, int flags = 0) 1522render (DC::Layout self, float x, float y, int flags = 0)
1114 PPCODE: 1523 CODE:
1524 rc_clear (self->rc);
1115 pango_opengl_render_layout_subpixel ( 1525 pango_opengl_render_layout_subpixel (
1116 self->pl, 1526 self->pl,
1527 self->rc,
1117 x * PANGO_SCALE, y * PANGO_SCALE, 1528 x * PANGO_SCALE, y * PANGO_SCALE,
1118 self->r, self->g, self->b, self->a, 1529 self->r, self->g, self->b, self->a,
1119 flags 1530 flags
1120 ); 1531 );
1532 // we assume that context_change actually clears/frees stuff
1533 // and does not do any recomputation...
1534 pango_layout_context_changed (self->pl);
1121 1535
1122MODULE = CFPlus PACKAGE = CFPlus::Texture
1123
1124void 1536void
1125pad2pot (SV *data_, SV *w_, SV *h_) 1537draw (DC::Layout self)
1126 CODE: 1538 CODE:
1127{ 1539{
1128 int ow = SvIV (w_); 1540 glEnable (GL_TEXTURE_2D);
1129 int oh = SvIV (h_); 1541 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1542 glEnable (GL_BLEND);
1543 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1544 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1545 glEnable (GL_ALPHA_TEST);
1546 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1130 1547
1131 if (ow && oh) 1548 rc_draw (self->rc);
1549
1550 glDisable (GL_ALPHA_TEST);
1551 glDisable (GL_BLEND);
1552 glDisable (GL_TEXTURE_2D);
1553}
1554
1555MODULE = Deliantra::Client PACKAGE = DC::Texture
1556
1557PROTOTYPES: ENABLE
1558
1559void
1560pad (SV *data_, int ow, int oh, int nw, int nh)
1561 CODE:
1562{
1563 if ((nw != ow || nh != oh) && SvOK (data_))
1132 { 1564 {
1133 int nw = minpot (ow);
1134 int nh = minpot (oh);
1135
1136 if (nw != ow || nh != oh)
1137 {
1138 if (SvOK (data_))
1139 {
1140 STRLEN datalen; 1565 STRLEN datalen;
1141 char *data = SvPVbyte (data_, datalen); 1566 char *data = SvPVbyte (data_, datalen);
1142 int bpp = datalen / (ow * oh); 1567 int bpp = datalen / (ow * oh);
1143 SV *result_ = sv_2mortal (newSV (nw * nh * bpp)); 1568 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1144 1569
1145 SvPOK_only (result_); 1570 SvPOK_only (result_);
1146 SvCUR_set (result_, nw * nh * bpp); 1571 SvCUR_set (result_, nw * nh * bpp);
1147 1572
1148 memset (SvPVX (result_), 0, nw * nh * bpp); 1573 memset (SvPVX (result_), 0, nw * nh * bpp);
1149 while (oh--) 1574 while (oh--)
1150 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp); 1575 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1151 1576
1152 sv_setsv (data_, result_); 1577 sv_setsv (data_, result_);
1153 }
1154
1155 sv_setiv (w_, nw);
1156 sv_setiv (h_, nh);
1157 }
1158 } 1578 }
1159} 1579}
1160 1580
1161void 1581void
1162draw_quad (SV *self, float x, float y, float w = 0., float h = 0.) 1582draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
… …
1168{ 1588{
1169 HV *hv = (HV *)SvRV (self); 1589 HV *hv = (HV *)SvRV (self);
1170 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1590 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
1171 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1591 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
1172 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1592 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
1593
1594 if (name <= 0)
1595 XSRETURN_EMPTY;
1173 1596
1174 if (items < 5) 1597 if (items < 5)
1175 { 1598 {
1176 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1599 w = SvNV (*hv_fetch (hv, "w", 1, 1));
1177 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1600 h = SvNV (*hv_fetch (hv, "h", 1, 1));
… …
1205 glDisable (GL_ALPHA_TEST); 1628 glDisable (GL_ALPHA_TEST);
1206 glDisable (GL_BLEND); 1629 glDisable (GL_BLEND);
1207 } 1630 }
1208} 1631}
1209 1632
1210MODULE = CFPlus PACKAGE = CFPlus::Map 1633IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1634 CODE:
1635{
1636 GLint width;
1637 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1638 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1639 RETVAL = width > 0;
1640}
1641 OUTPUT:
1642 RETVAL
1211 1643
1212CFPlus::Map 1644MODULE = Deliantra::Client PACKAGE = DC::Map
1645
1646PROTOTYPES: DISABLE
1647
1648DC::Map
1213new (SV *class) 1649new (SV *class)
1214 CODE: 1650 CODE:
1215 New (0, RETVAL, 1, struct map); 1651 New (0, RETVAL, 1, struct map);
1216 RETVAL->x = 0; 1652 RETVAL->x = 0;
1217 RETVAL->y = 0; 1653 RETVAL->y = 0;
1218 RETVAL->w = 0; 1654 RETVAL->w = 0;
1219 RETVAL->h = 0; 1655 RETVAL->h = 0;
1220 RETVAL->ox = 0; 1656 RETVAL->ox = 0;
1221 RETVAL->oy = 0; 1657 RETVAL->oy = 0;
1222 RETVAL->faces = 8192; 1658 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1223 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1659 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
1224 RETVAL->texs = 8192;
1225 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
1226 RETVAL->rows = 0; 1660 RETVAL->rows = 0;
1227 RETVAL->row = 0; 1661 RETVAL->row = 0;
1228 OUTPUT: 1662 OUTPUT:
1229 RETVAL 1663 RETVAL
1230 1664
1231void 1665void
1232DESTROY (CFPlus::Map self) 1666DESTROY (DC::Map self)
1233 CODE: 1667 CODE:
1234{ 1668{
1235 map_clear (self); 1669 map_clear (self);
1236 Safefree (self->face); 1670 Safefree (self->face2tile);
1237 Safefree (self->tex); 1671 Safefree (self->tex);
1238 Safefree (self); 1672 Safefree (self);
1239} 1673}
1240 1674
1241void 1675void
1242resize (CFPlus::Map self, int map_width, int map_height) 1676resize (DC::Map self, int map_width, int map_height)
1243 CODE: 1677 CODE:
1244 self->w = map_width; 1678 self->w = map_width;
1245 self->h = map_height; 1679 self->h = map_height;
1246 1680
1247void 1681void
1248clear (CFPlus::Map self) 1682clear (DC::Map self)
1249 CODE: 1683 CODE:
1250 map_clear (self); 1684 map_clear (self);
1251 1685
1252void 1686void
1253set_face (CFPlus::Map self, int face, int texid) 1687set_tileid (DC::Map self, int face, int tile)
1254 CODE: 1688 CODE:
1255{ 1689{
1256 while (self->faces <= face) 1690 need_facenum (self, face); self->face2tile [face] = tile;
1257 { 1691 need_texid (self, tile);
1258 Append (mapface, self->face, self->faces, self->faces);
1259 self->faces *= 2;
1260 }
1261
1262 self->face [face] = texid;
1263} 1692}
1264 1693
1265void 1694void
1695set_smooth (DC::Map self, int face, int smooth, int level)
1696 CODE:
1697{
1698 tileid texid;
1699 maptex *tex;
1700
1701 if (face < 0 || face >= self->faces)
1702 return;
1703
1704 if (smooth < 0 || smooth >= self->faces)
1705 return;
1706
1707 texid = self->face2tile [face];
1708
1709 if (!texid)
1710 return;
1711
1712 tex = self->tex + texid;
1713 tex->smoothtile = self->face2tile [smooth];
1714 tex->smoothlevel = level;
1715}
1716
1717void
1266set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1718set_texture (DC::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1267 CODE: 1719 CODE:
1268{ 1720{
1269 while (self->texs <= texid) 1721 need_texid (self, texid);
1270 {
1271 Append (maptex, self->tex, self->texs, self->texs);
1272 self->texs *= 2;
1273 }
1274 1722
1275 { 1723 {
1276 maptex *tex = self->tex + texid; 1724 maptex *tex = self->tex + texid;
1277 1725
1278 tex->name = name; 1726 tex->name = name;
… …
1295 // from transparent color bleeding and ugly wrapping effects. 1743 // from transparent color bleeding and ugly wrapping effects.
1296 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1744 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1297} 1745}
1298 1746
1299int 1747int
1300ox (CFPlus::Map self) 1748ox (DC::Map self)
1301 ALIAS: 1749 ALIAS:
1302 oy = 1 1750 oy = 1
1303 x = 2 1751 x = 2
1304 y = 3 1752 y = 3
1305 w = 4 1753 w = 4
… …
1316 } 1764 }
1317 OUTPUT: 1765 OUTPUT:
1318 RETVAL 1766 RETVAL
1319 1767
1320void 1768void
1321scroll (CFPlus::Map self, int dx, int dy) 1769scroll (DC::Map self, int dx, int dy)
1322 CODE: 1770 CODE:
1323{ 1771{
1324 if (dx > 0) 1772 if (dx > 0)
1325 map_blank (self, self->x, self->y, dx, self->h); 1773 map_blank (self, self->x, self->y, dx, self->h);
1326 else if (dx < 0) 1774 else if (dx < 0)
1327 map_blank (self, self->x + self->w + dx + 1, self->y, -dx, self->h); 1775 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
1328 1776
1329 if (dy > 0) 1777 if (dy > 0)
1330 map_blank (self, self->x, self->y, self->w, dy); 1778 map_blank (self, self->x, self->y, self->w, dy);
1331 else if (dy < 0) 1779 else if (dy < 0)
1332 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, -dy); 1780 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
1333 1781
1334 self->ox += dx; self->x += dx; 1782 self->ox += dx; self->x += dx;
1335 self->oy += dy; self->y += dy; 1783 self->oy += dy; self->y += dy;
1336 1784
1337 while (self->y < 0) 1785 while (self->y < 0)
… …
1341 self->rows += MAP_EXTEND_Y; 1789 self->rows += MAP_EXTEND_Y;
1342 self->y += MAP_EXTEND_Y; 1790 self->y += MAP_EXTEND_Y;
1343 } 1791 }
1344} 1792}
1345 1793
1346void 1794SV *
1347map1a_update (CFPlus::Map self, SV *data_, int extmap) 1795map1a_update (DC::Map self, SV *data_, int extmap)
1348 CODE: 1796 CODE:
1349{ 1797{
1350 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1798 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1351 uint8_t *data_end = (uint8_t *)SvEND (data_); 1799 uint8_t *data_end = (uint8_t *)SvEND (data_);
1352 mapcell *cell; 1800 mapcell *cell;
1353 int x, y, flags; 1801 int x, y, z, flags;
1802 AV *missing = newAV ();
1803 RETVAL = newRV_noinc ((SV *)missing);
1354 1804
1355 while (data < data_end - 1) 1805 while (data < data_end - 1)
1356 { 1806 {
1357 flags = (data [0] << 8) + data [1]; data += 2; 1807 flags = (data [0] << 8) + data [1]; data += 2;
1358 1808
… …
1378 uint8_t ext, cmd; 1828 uint8_t ext, cmd;
1379 1829
1380 do 1830 do
1381 { 1831 {
1382 ext = *data++; 1832 ext = *data++;
1383 cmd = ext & 0x3f; 1833 cmd = ext & 0x7f;
1384 1834
1385 if (cmd < 4) 1835 if (cmd < 4)
1386 cell->darkness = 255 - ext * 64 + 1; 1836 cell->darkness = 255 - ext * 64 + 1;
1387 else if (cmd == 5) // health 1837 else if (cmd == 5) // health
1388 { 1838 {
1389 cell->stat_width = 1; 1839 cell->stat_width = 1;
1390 cell->stat_hp = *data++; 1840 cell->stat_hp = *data++;
1391 } 1841 }
1392 else if (cmd == 6) // monster width 1842 else if (cmd == 6) // monster width
1393 cell->stat_width = *data++ + 1; 1843 cell->stat_width = *data++ + 1;
1394 else if (cmd == 0x47) // monster width 1844 else if (cmd == 0x47)
1395 { 1845 {
1396 if (*data == 4) 1846 if (*data == 1) cell->player = data [1];
1397 ; // decode player tag 1847 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
1848 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
1849 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
1398 1850
1399 data += *data + 1; 1851 data += *data + 1;
1400 } 1852 }
1401 else if (cmd == 8) // cell flags 1853 else if (cmd == 8) // cell flags
1402 cell->flags = *data++; 1854 cell->flags = *data++;
… …
1409 } 1861 }
1410 else 1862 else
1411 cell->darkness = *data++ + 1; 1863 cell->darkness = *data++ + 1;
1412 } 1864 }
1413 1865
1866 for (z = 0; z <= 2; ++z)
1414 if (flags & 4) 1867 if (flags & (4 >> z))
1415 { 1868 {
1416 cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2; 1869 faceid face = (data [0] << 8) + data [1]; data += 2;
1870 need_facenum (self, face);
1871 cell->tile [z] = self->face2tile [face];
1872
1873 if (cell->tile [z])
1874 {
1875 maptex *tex = self->tex + cell->tile [z];
1876 if (!tex->name)
1877 av_push (missing, newSViv (cell->tile [z]));
1878
1879 if (tex->smoothtile)
1880 {
1881 maptex *smooth = self->tex + tex->smoothtile;
1882 if (!smooth->name)
1883 av_push (missing, newSViv (tex->smoothtile));
1884 }
1885 }
1417 } 1886 }
1418
1419 if (flags & 2)
1420 {
1421 cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2;
1422 }
1423
1424 if (flags & 1)
1425 {
1426 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
1427 }
1428 } 1887 }
1429 else 1888 else
1430 cell->darkness = 0; 1889 CELL_CLEAR (cell);
1431 } 1890 }
1432} 1891}
1892 OUTPUT:
1893 RETVAL
1433 1894
1434SV * 1895SV *
1435mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 1896mapmap (DC::Map self, int x0, int y0, int w, int h)
1436 CODE: 1897 CODE:
1437{ 1898{
1438 int x1, x; 1899 int x1, x;
1439 int y1, y; 1900 int y1, y;
1440 int z; 1901 int z;
… …
1461 { 1922 {
1462 mapcell *cell = row->col + (x - row->c0); 1923 mapcell *cell = row->col + (x - row->c0);
1463 1924
1464 for (z = 0; z <= 0; z++) 1925 for (z = 0; z <= 0; z++)
1465 { 1926 {
1466 mapface face = cell->face [z];
1467
1468 if (face)
1469 {
1470 maptex tex = self->tex [face]; 1927 maptex tex = self->tex [cell->tile [z]];
1471 int a0 = 255 - tex.a; 1928 int a0 = 255 - tex.a;
1472 int a1 = tex.a; 1929 int a1 = tex.a;
1473 1930
1474 r = (r * a0 + tex.r * a1) / 255; 1931 r = (r * a0 + tex.r * a1) / 255;
1475 g = (g * a0 + tex.g * a1) / 255; 1932 g = (g * a0 + tex.g * a1) / 255;
1476 b = (b * a0 + tex.b * a1) / 255; 1933 b = (b * a0 + tex.b * a1) / 255;
1477 a = (a * a0 + tex.a * a1) / 255; 1934 a = (a * a0 + tex.a * a1) / 255;
1478 }
1479 } 1935 }
1480 } 1936 }
1481 1937
1482 *map++ = (r ) 1938 *map++ = (r )
1483 | (g << 8) 1939 | (g << 8)
… …
1490} 1946}
1491 OUTPUT: 1947 OUTPUT:
1492 RETVAL 1948 RETVAL
1493 1949
1494void 1950void
1495draw (CFPlus::Map self, int mx, int my, int sw, int sh) 1951draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1496 CODE: 1952 CODE:
1497{ 1953{
1498 int x, y, z; 1954 int x, y, z;
1499 int last_name;
1500 mapface face;
1501 1955
1502 glColor4ub (255, 255, 255, 255); 1956 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1957 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1958 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1959 smooth_key skey;
1960 int pl_x, pl_y;
1961 maptex pl_tex;
1962 rc_t *rc = rc_alloc ();
1963 rc_key_t key;
1964 rc_array_t *arr;
1965
1966 pl_tex.name = 0;
1967
1968 // thats current max. sorry.
1969 if (sw > 255) sw = 255;
1970 if (sh > 255) sh = 255;
1971
1972 // clear key, in case of extra padding
1973 memset (&skey, 0, sizeof (skey));
1974
1975 memset (&key, 0, sizeof (key));
1976 key.r = 255;
1977 key.g = 255;
1978 key.b = 255;
1979 key.a = 255;
1980 key.mode = GL_QUADS;
1981 key.format = GL_T2F_V3F;
1982 key.texname = -1;
1983
1984 mx += self->x;
1985 my += self->y;
1986
1987 // first pass: determine smooth_max
1988 // rather ugly, if you ask me
1989 // could also be stored inside mapcell and updated on change
1990 memset (smooth_max, 0, sizeof (smooth_max));
1991
1992 for (y = 0; y < sh; y++)
1993 if (0 <= y + my && y + my < self->rows)
1994 {
1995 maprow *row = self->row + (y + my);
1996
1997 for (x = 0; x < sw; x++)
1998 if (row->c0 <= x + mx && x + mx < row->c1)
1999 {
2000 mapcell *cell = row->col + (x + mx - row->c0);
2001
2002 smooth_max[x + 1][y + 1] =
2003 MAX (self->tex [cell->tile [0]].smoothlevel,
2004 MAX (self->tex [cell->tile [1]].smoothlevel,
2005 self->tex [cell->tile [2]].smoothlevel));
2006 }
2007 }
1503 2008
1504 glEnable (GL_BLEND); 2009 glEnable (GL_BLEND);
1505 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2010 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1506 glEnable (GL_TEXTURE_2D);
1507 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2011 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1508 2012
1509 glBegin (GL_QUADS);
1510
1511 last_name = 0;
1512
1513 mx += self->x;
1514 my += self->y;
1515
1516 for (z = 0; z < 3; z++) 2013 for (z = 0; z <= 2; z++)
2014 {
2015 memset (smooth_level, 0, sizeof (smooth_level));
2016
1517 for (y = 0; y < sh; y++) 2017 for (y = 0; y < sh; y++)
1518 if (0 <= y + my && y + my < self->rows) 2018 if (0 <= y + my && y + my < self->rows)
1519 { 2019 {
1520 maprow *row = self->row + (y + my); 2020 maprow *row = self->row + (y + my);
1521 2021
1522 for (x = 0; x < sw; x++) 2022 for (x = 0; x < sw; x++)
1523 if (row->c0 <= x + mx && x + mx < row->c1) 2023 if (row->c0 <= x + mx && x + mx < row->c1)
1524 { 2024 {
1525 mapcell *cell = row->col + (x + mx - row->c0); 2025 mapcell *cell = row->col + (x + mx - row->c0);
1526
1527 face = cell->face [z]; 2026 tileid tile = cell->tile [z];
2027
2028 if (tile)
2029 {
2030 maptex tex = self->tex [tile];
2031 int px = (x + 1) * T - tex.w;
2032 int py = (y + 1) * T - tex.h;
1528 2033
1529 if (face && face < self->texs) 2034 if (key.texname != tex.name)
2035 {
2036 if (!tex.name)
2037 tex = self->tex [2]; /* missing, replace by noface */
2038
2039 key.texname = tex.name;
2040 arr = rc_array (rc, &key);
2041 }
2042
2043 if (expect_false (cell->player == player) && expect_false (z == 2))
2044 {
2045 pl_x = px;
2046 pl_y = py;
2047 pl_tex = tex;
2048 continue;
2049 }
2050
2051 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2052 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
2053 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
2054 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2055
2056 if (expect_false (cell->flags) && expect_false (z == 2))
2057 {
2058 // overlays such as the speech bubble, probably more to come
2059 if (cell->flags & 1)
2060 {
2061 maptex tex = self->tex [1];
2062 int px = x * T + T * 2 / 32;
2063 int py = y * T - T * 6 / 32;
2064
2065 if (tex.name)
2066 {
2067 if (key.texname != tex.name)
2068 {
2069 key.texname = tex.name;
2070 arr = rc_array (rc, &key);
2071 }
2072
2073 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2074 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
2075 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
2076 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
2077 }
2078 }
2079 }
2080
2081 // update smooth hash
2082 if (tex.smoothtile)
2083 {
2084 skey.tile = tex.smoothtile;
2085 skey.level = tex.smoothlevel;
2086
2087 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
2088
2089 // add bits to current tile and all neighbours. skey.x|y is
2090 // shifted +1|+1 so we always stay positive.
2091
2092 // bits is ___n cccc CCCC bbbb
2093 // n do not draw borders&corners
2094 // c draw these corners, but...
2095 // C ... not these
2096 // b draw these borders
2097
2098 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
2099 // ┃· ·· ·┃ ━━
2100
2101 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
2102 // ·· ·· ·┏ ┓·
2103
2104 // full tile
2105 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
2106
2107 // borders
2108 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
2109 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
2110 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
2111 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
2112
2113 // corners
2114 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
2115 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
2116 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
2117 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
2118 }
2119 }
2120 }
2121 }
2122
2123 rc_draw (rc);
2124 rc_clear (rc);
2125
2126 // go through all smoothlevels, lowest to highest, then draw.
2127 // this is basically counting sort
2128 {
2129 int w, b;
2130
2131 glEnable (GL_TEXTURE_2D);
2132 glBegin (GL_QUADS);
2133 for (w = 0; w < 256 / 32; ++w)
2134 {
2135 uint32_t smask = smooth_level [w];
2136 if (smask)
2137 for (b = 0; b < 32; ++b)
2138 if (smask & (((uint32_t)1) << b))
1530 { 2139 {
1531 maptex tex = self->tex [face]; 2140 int level = (w << 5) | b;
1532 int px = (x + 1) * 32 - tex.w; 2141 HE *he;
1533 int py = (y + 1) * 32 - tex.h;
1534 2142
1535 if (last_name != tex.name) 2143 hv_iterinit (smooth);
2144 while ((he = hv_iternext (smooth)))
1536 { 2145 {
1537 glEnd (); 2146 smooth_key *skey = (smooth_key *)HeKEY (he);
1538 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2147 IV bits = SvIVX (HeVAL (he));
1539 glBegin (GL_QUADS);
1540 }
1541 2148
1542 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1543 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1544 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1545 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1546 }
1547
1548 if (cell->flags && z == 2)
1549 {
1550 if (cell->flags & 1) 2149 if (!(bits & 0x1000)
2150 && skey->level == level
2151 && level > smooth_max [skey->x][skey->y])
1551 { 2152 {
1552 maptex tex = self->tex [1]; 2153 maptex tex = self->tex [skey->tile];
1553 int px = (x + 1) * 32 - tex.w + 2; 2154 int px = (((int)skey->x) - 1) * T;
1554 int py = (y + 1) * 32 - tex.h - 6; 2155 int py = (((int)skey->y) - 1) * T;
2156 int border = bits & 15;
2157 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2158 float dx = tex.s * .0625f; // 16 images/row
2159 float dy = tex.t * .5f ; // 2 images/column
1555 2160
2161 if (tex.name)
2162 {
2163 // this time avoiding texture state changes
2164 // save gobs of state changes.
2165 if (key.texname != tex.name)
2166 {
1556 glEnd (); 2167 glEnd ();
1557 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2168 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1558 glBegin (GL_QUADS); 2169 glBegin (GL_QUADS);
2170 }
1559 2171
2172 if (border)
2173 {
2174 float ox = border * dx;
2175
2176 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2177 glTexCoord2f (ox , dy ); glVertex2i (px , py + T);
2178 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);
2179 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );
2180 }
2181
2182 if (corner)
2183 {
2184 float ox = corner * dx;
2185
1560 glTexCoord2f (0 , 0 ); glVertex2f (px , py ); 2186 glTexCoord2f (ox , dy ); glVertex2i (px , py );
1561 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h); 2187 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);
1562 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h); 2188 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);
1563 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py ); 2189 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );
2190 }
2191 }
2192 }
1564 } 2193 }
1565 } 2194 }
1566 }
1567 } 2195 }
1568 2196
1569 glEnd (); 2197 glEnd ();
1570
1571 glDisable (GL_TEXTURE_2D); 2198 glDisable (GL_TEXTURE_2D);
2199 key.texname = -1;
2200 }
2201
2202 hv_clear (smooth);
2203 }
2204
2205 if (pl_tex.name)
2206 {
2207 maptex tex = pl_tex;
2208 int px = pl_x + sdx;
2209 int py = pl_y + sdy;
2210
2211 key.texname = tex.name;
2212 arr = rc_array (rc, &key);
2213
2214 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2215 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
2216 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
2217 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
2218
2219 rc_draw (rc);
2220 }
2221
1572 glDisable (GL_BLEND); 2222 glDisable (GL_BLEND);
2223 rc_free (rc);
1573 2224
1574 // top layer: overlays such as the health bar 2225 // top layer: overlays such as the health bar
1575 for (y = 0; y < sh; y++) 2226 for (y = 0; y < sh; y++)
1576 if (0 <= y + my && y + my < self->rows) 2227 if (0 <= y + my && y + my < self->rows)
1577 { 2228 {
… …
1580 for (x = 0; x < sw; x++) 2231 for (x = 0; x < sw; x++)
1581 if (row->c0 <= x + mx && x + mx < row->c1) 2232 if (row->c0 <= x + mx && x + mx < row->c1)
1582 { 2233 {
1583 mapcell *cell = row->col + (x + mx - row->c0); 2234 mapcell *cell = row->col + (x + mx - row->c0);
1584 2235
1585 int px = x * 32; 2236 int px = x * T;
1586 int py = y * 32; 2237 int py = y * T;
1587 2238
1588 if (cell->stat_hp) 2239 if (cell->stat_hp)
1589 { 2240 {
1590 int width = cell->stat_width * 32; 2241 int width = cell->stat_width * T;
1591 int thick = sh / 28 + 1 + cell->stat_width; 2242 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1592 2243
1593 glColor3ub (0, 0, 0); 2244 glColor3ub (0, 0, 0);
1594 glRectf (px + 1, py - thick - 2, 2245 glRectf (px + 1, py - thick - 2,
1595 px + width - 1, py); 2246 px + width - 1, py);
1596 2247
… …
1602 } 2253 }
1603 } 2254 }
1604} 2255}
1605 2256
1606void 2257void
1607draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data) 2258draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data)
1608 CODE: 2259 CODE:
1609{ 2260{
1610 static float color[16][3] = { 2261 static float color[16][3] = {
1611 { 0.00F, 0.00F, 0.00F }, 2262 { 0.00F, 0.00F, 0.00F },
1612 { 1.00F, 1.00F, 1.00F }, 2263 { 1.00F, 1.00F, 1.00F },
… …
1662 glDisable (GL_BLEND); 2313 glDisable (GL_BLEND);
1663 glDisable (GL_TEXTURE_2D); 2314 glDisable (GL_TEXTURE_2D);
1664} 2315}
1665 2316
1666void 2317void
1667fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh) 2318fow_texture (DC::Map self, int mx, int my, int sw, int sh)
1668 PPCODE: 2319 PPCODE:
1669{ 2320{
1670 int x, y; 2321 int x, y;
2322 int sw1 = sw + 2;
2323 int sh1 = sh + 2;
2324 int sh3 = sh * 3;
1671 int sw4 = (sw + 3) & ~3; 2325 int sw34 = (sw * 3 + 3) & ~3;
2326 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
1672 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2327 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
1673 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2328 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1674 2329
1675 memset (darkness, 255, sw4 * sh);
1676 SvPOK_only (darkness_sv); 2330 SvPOK_only (darkness3_sv);
1677 SvCUR_set (darkness_sv, sw4 * sh); 2331 SvCUR_set (darkness3_sv, sw34 * sh3);
1678 2332
1679 mx += self->x; 2333 mx += self->x - 1;
1680 my += self->y; 2334 my += self->y - 1;
1681 2335
2336 memset (darkness1, 255 - FOW_DARKNESS, sw1 * sh1);
2337
1682 for (y = 0; y < sh; y++) 2338 for (y = 0; y < sh1; y++)
1683 if (0 <= y + my && y + my < self->rows) 2339 if (0 <= y + my && y + my < self->rows)
1684 { 2340 {
1685 maprow *row = self->row + (y + my); 2341 maprow *row = self->row + (y + my);
1686 2342
1687 for (x = 0; x < sw; x++) 2343 for (x = 0; x < sw1; x++)
1688 if (row->c0 <= x + mx && x + mx < row->c1) 2344 if (row->c0 <= x + mx && x + mx < row->c1)
1689 { 2345 {
1690 mapcell *cell = row->col + (x + mx - row->c0); 2346 mapcell *cell = row->col + (x + mx - row->c0);
1691 2347
1692 darkness[y * sw4 + x] = cell->darkness 2348 darkness1 [y * sw1 + x] = cell->darkness
1693 ? 255 - (cell->darkness - 1) 2349 ? 255 - (cell->darkness - 1)
1694 : 255 - FOW_DARKNESS; 2350 : 255 - FOW_DARKNESS;
1695 } 2351 }
1696 } 2352 }
1697 2353
2354 for (y = 0; y < sh; ++y)
2355 for (x = 0; x < sw; ++x)
2356 {
2357 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2358 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2359 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2360 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2361 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2362 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2363 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2364 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2365 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2366
2367 uint8_t r11 = (d11 + d21 + d12) / 3;
2368 uint8_t r21 = d21;
2369 uint8_t r31 = (d21 + d31 + d32) / 3;
2370
2371 uint8_t r12 = d12;
2372 uint8_t r22 = d22;
2373 uint8_t r32 = d32;
2374
2375 uint8_t r13 = (d13 + d23 + d12) / 3;
2376 uint8_t r23 = d23;
2377 uint8_t r33 = (d23 + d33 + d32) / 3;
2378
2379 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2380 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2381 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2382 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2383 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2384 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2385 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2386 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2387 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2388 }
2389
2390 free (darkness1);
2391
1698 EXTEND (SP, 3); 2392 EXTEND (SP, 3);
1699 PUSHs (sv_2mortal (newSViv (sw4))); 2393 PUSHs (sv_2mortal (newSViv (sw34)));
1700 PUSHs (sv_2mortal (newSViv (sh))); 2394 PUSHs (sv_2mortal (newSViv (sh3)));
1701 PUSHs (darkness_sv); 2395 PUSHs (darkness3_sv);
1702} 2396}
1703 2397
1704SV * 2398SV *
1705get_rect (CFPlus::Map self, int x0, int y0, int w, int h) 2399get_rect (DC::Map self, int x0, int y0, int w, int h)
1706 CODE: 2400 CODE:
1707{ 2401{
1708 int x, y, x1, y1; 2402 int x, y, x1, y1;
1709 SV *data_sv = newSV (w * h * 7 + 5); 2403 SV *data_sv = newSV (w * h * 7 + 5);
1710 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2404 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
1735 if (row && row->c0 <= x && x < row->c1) 2429 if (row && row->c0 <= x && x < row->c1)
1736 { 2430 {
1737 mapcell *cell = row->col + (x - row->c0); 2431 mapcell *cell = row->col + (x - row->c0);
1738 uint8_t flags = 0; 2432 uint8_t flags = 0;
1739 2433
1740 if (cell->face [0]) flags |= 1; 2434 if (cell->tile [0]) flags |= 1;
1741 if (cell->face [1]) flags |= 2; 2435 if (cell->tile [1]) flags |= 2;
1742 if (cell->face [2]) flags |= 4; 2436 if (cell->tile [2]) flags |= 4;
1743 2437
1744 *data++ = flags; 2438 *data++ = flags;
1745 2439
1746 if (flags & 1) 2440 if (flags & 1)
1747 { 2441 {
2442 tileid tile = cell->tile [0];
1748 *data++ = cell->face [0] >> 8; 2443 *data++ = tile >> 8;
1749 *data++ = cell->face [0]; 2444 *data++ = tile;
1750 } 2445 }
1751 2446
1752 if (flags & 2) 2447 if (flags & 2)
1753 { 2448 {
2449 tileid tile = cell->tile [1];
1754 *data++ = cell->face [1] >> 8; 2450 *data++ = tile >> 8;
1755 *data++ = cell->face [1]; 2451 *data++ = tile;
1756 } 2452 }
1757 2453
1758 if (flags & 4) 2454 if (flags & 4)
1759 { 2455 {
2456 tileid tile = cell->tile [2];
1760 *data++ = cell->face [2] >> 8; 2457 *data++ = tile >> 8;
1761 *data++ = cell->face [2]; 2458 *data++ = tile;
1762 } 2459 }
1763 } 2460 }
1764 else 2461 else
1765 *data++ = 0; 2462 *data++ = 0;
1766 } 2463 }
1767 } 2464 }
1768 2465
2466 /* if size is w*h + 5 then no data has been found */
2467 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2468 {
1769 SvPOK_only (data_sv); 2469 SvPOK_only (data_sv);
1770 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2470 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2471 }
2472
1771 RETVAL = data_sv; 2473 RETVAL = data_sv;
1772} 2474}
1773 OUTPUT: 2475 OUTPUT:
1774 RETVAL 2476 RETVAL
1775 2477
1776void 2478void
1777set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2479set_rect (DC::Map self, int x0, int y0, SV *data_sv)
1778 PPCODE: 2480 PPCODE:
1779{ 2481{
1780 int x, y, z; 2482 int x, y, z;
1781 int w, h; 2483 int w, h;
1782 int x1, y1; 2484 int x1, y1;
2485 STRLEN len;
2486 uint8_t *data, *end;
2487
2488 len = SvLEN (data_sv);
2489 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2490 data = SvPVbyte_nolen (data_sv);
2491 end = data + len + 8;
2492
2493 if (len < 5)
2494 XSRETURN_EMPTY;
1783 2495
1784 if (*data++ != 0) 2496 if (*data++ != 0)
1785 return; /* version mismatch */ 2497 XSRETURN_EMPTY; /* version mismatch */
1786 2498
1787 w = *data++ << 8; w |= *data++; 2499 w = *data++ << 8; w |= *data++;
1788 h = *data++ << 8; h |= *data++; 2500 h = *data++ << 8; h |= *data++;
1789 2501
1790 // we need to do this 'cause we don't keep an absolute coord system for rows 2502 // we need to do this 'cause we don't keep an absolute coord system for rows
… …
1802 { 2514 {
1803 maprow *row = map_get_row (self, y); 2515 maprow *row = map_get_row (self, y);
1804 2516
1805 for (x = x0; x < x1; x++) 2517 for (x = x0; x < x1; x++)
1806 { 2518 {
2519 uint8_t flags;
2520
2521 if (data + 7 >= end)
2522 XSRETURN_EMPTY;
2523
1807 uint8_t flags = *data++; 2524 flags = *data++;
1808 2525
1809 if (flags) 2526 if (flags)
1810 { 2527 {
1811 mapface face[3] = { 0, 0, 0 };
1812
1813 mapcell *cell = row_get_cell (row, x); 2528 mapcell *cell = row_get_cell (row, x);
2529 tileid tile[3] = { 0, 0, 0 };
1814 2530
1815 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2531 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
1816 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2532 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
1817 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2533 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
1818 2534
1819 if (cell->darkness == 0) 2535 if (cell->darkness == 0)
1820 { 2536 {
1821 cell->darkness = 0; 2537 /*cell->darkness = 0;*/
2538 EXTEND (SP, 3);
1822 2539
1823 for (z = 0; z <= 2; z++) 2540 for (z = 0; z <= 2; z++)
1824 { 2541 {
1825 cell->face[z] = face[z]; 2542 tileid t = tile [z];
1826 2543
1827 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2544 if (t >= self->texs || (t && !self->tex [t].name))
2545 {
1828 XPUSHs (sv_2mortal (newSViv (face[z]))); 2546 PUSHs (sv_2mortal (newSViv (t)));
2547 need_texid (self, t);
2548 }
2549
2550 cell->tile [z] = t;
1829 } 2551 }
1830 } 2552 }
1831 } 2553 }
1832 } 2554 }
1833 } 2555 }
1834} 2556}
1835 2557
1836MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2558MODULE = Deliantra::Client PACKAGE = DC::RW
1837 2559
1838CFPlus::MixChunk 2560DC::RW
1839new_from_file (SV *class, char *path) 2561new (SV *class, SV *data_sv)
1840 CODE: 2562 CODE:
1841 RETVAL = Mix_LoadWAV (path); 2563{
2564 STRLEN datalen;
2565 char *data = SvPVbyte (data_sv, datalen);
2566
2567 RETVAL = SDL_RWFromConstMem (data, datalen);
2568}
1842 OUTPUT: 2569 OUTPUT:
1843 RETVAL 2570 RETVAL
1844 2571
2572DC::RW
2573new_from_file (SV *class, const char *path, const char *mode = "rb")
2574 CODE:
2575 RETVAL = SDL_RWFromFile (path, mode);
2576 OUTPUT:
2577 RETVAL
2578
2579# fails on win32:
2580# dc.xs(2268) : error C2059: syntax error : '('
1845void 2581#void
2582#close (DC::RW self)
2583# CODE:
2584# (self->(close)) (self);
2585
2586MODULE = Deliantra::Client PACKAGE = DC::Channel
2587
2588PROTOTYPES: DISABLE
2589
2590DC::Channel
2591find ()
2592 CODE:
2593{
2594 RETVAL = Mix_GroupAvailable (-1);
2595
2596 if (RETVAL < 0)
2597 {
2598 RETVAL = Mix_GroupOldest (-1);
2599
2600 if (RETVAL < 0)
2601 XSRETURN_UNDEF;
2602
2603 Mix_HaltChannel (RETVAL);
2604 }
2605
2606 Mix_UnregisterAllEffects (RETVAL);
2607 Mix_Volume (RETVAL, 128);
2608}
2609 OUTPUT:
2610 RETVAL
2611
2612void
2613halt (DC::Channel self)
2614 CODE:
2615 Mix_HaltChannel (self);
2616
2617void
2618expire (DC::Channel self, int ticks = -1)
2619 CODE:
2620 Mix_ExpireChannel (self, ticks);
2621
2622void
2623fade_out (DC::Channel self, int ticks = -1)
2624 CODE:
2625 Mix_FadeOutChannel (self, ticks);
2626
2627int
2628volume (DC::Channel self, int volume)
2629 CODE:
2630 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2631 OUTPUT:
2632 RETVAL
2633
2634void
2635unregister_all_effects (DC::Channel self)
2636 CODE:
2637 Mix_UnregisterAllEffects (self);
2638
2639void
2640set_panning (DC::Channel self, int left, int right)
2641 CODE:
2642 left = CLAMP (left , 0, 255);
2643 right = CLAMP (right, 0, 255);
2644 Mix_SetPanning (self, left, right);
2645
2646void
2647set_distance (DC::Channel self, int distance)
2648 CODE:
2649 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2650
2651void
2652set_position (DC::Channel self, int angle, int distance)
2653 CODE:
2654
2655void
2656set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2657 CODE:
2658{
2659 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2660 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);
2661 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2662}
2663
2664void
2665set_reverse_stereo (DC::Channel self, int flip)
2666 CODE:
2667 Mix_SetReverseStereo (self, flip);
2668
2669MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2670
2671PROTOTYPES: DISABLE
2672
2673DC::MixChunk
2674new (SV *class, DC::RW rwops)
2675 CODE:
2676 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2677 OUTPUT:
2678 RETVAL
2679
2680void
1846DESTROY (CFPlus::MixChunk self) 2681DESTROY (DC::MixChunk self)
1847 CODE: 2682 CODE:
1848 Mix_FreeChunk (self); 2683 Mix_FreeChunk (self);
1849 2684
1850int 2685int
1851volume (CFPlus::MixChunk self, int volume = -1) 2686volume (DC::MixChunk self, int volume = -1)
1852 CODE: 2687 CODE:
2688 if (items > 1)
2689 volume = CLAMP (volume, 0, 128);
1853 RETVAL = Mix_VolumeChunk (self, volume); 2690 RETVAL = Mix_VolumeChunk (self, volume);
1854 OUTPUT: 2691 OUTPUT:
1855 RETVAL 2692 RETVAL
1856 2693
1857int 2694DC::Channel
1858play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1) 2695play (DC::MixChunk self, DC::Channel channel = -1, int loops = 0, int ticks = -1)
1859 CODE: 2696 CODE:
2697{
1860 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2698 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2699
2700 if (RETVAL < 0)
2701 XSRETURN_UNDEF;
2702
2703 if (channel < 0)
2704 {
2705 Mix_UnregisterAllEffects (RETVAL);
2706 Mix_Volume (RETVAL, 128);
2707 }
2708}
1861 OUTPUT: 2709 OUTPUT:
1862 RETVAL 2710 RETVAL
1863 2711
1864MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2712MODULE = Deliantra::Client PACKAGE = DC::MixMusic
1865 2713
1866int 2714int
1867volume (int volume = -1) 2715volume (int volume = -1)
2716 PROTOTYPE: ;$
1868 CODE: 2717 CODE:
2718 if (items > 0)
2719 volume = CLAMP (volume, 0, 128);
1869 RETVAL = Mix_VolumeMusic (volume); 2720 RETVAL = Mix_VolumeMusic (volume);
1870 OUTPUT: 2721 OUTPUT:
1871 RETVAL 2722 RETVAL
1872 2723
2724void
2725fade_out (int ms)
2726 CODE:
2727 Mix_FadeOutMusic (ms);
2728
2729void
2730halt ()
2731 CODE:
2732 Mix_HaltMusic ();
2733
1873CFPlus::MixMusic 2734DC::MixMusic
1874new_from_file (SV *class, char *path) 2735new (SV *class, DC::RW rwops)
1875 CODE: 2736 CODE:
1876 RETVAL = Mix_LoadMUS (path); 2737 RETVAL = Mix_LoadMUS_RW (rwops);
1877 OUTPUT: 2738 OUTPUT:
1878 RETVAL 2739 RETVAL
1879 2740
1880void 2741void
1881DESTROY (CFPlus::MixMusic self) 2742DESTROY (DC::MixMusic self)
1882 CODE: 2743 CODE:
1883 Mix_FreeMusic (self); 2744 Mix_FreeMusic (self);
1884 2745
1885int 2746int
1886play (CFPlus::MixMusic self, int loops = -1) 2747play (DC::MixMusic self, int loops = -1)
1887 CODE: 2748 CODE:
1888 RETVAL = Mix_PlayMusic (self, loops); 2749 RETVAL = Mix_PlayMusic (self, loops);
1889 OUTPUT: 2750 OUTPUT:
1890 RETVAL 2751 RETVAL
1891 2752
1892MODULE = CFPlus PACKAGE = CFPlus::OpenGL 2753void
2754fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2755 CODE:
2756 Mix_FadeInMusicPos (self, loops, ms, position);
2757
2758MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2759
2760PROTOTYPES: ENABLE
1893 2761
1894BOOT: 2762BOOT:
1895{ 2763{
1896 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 2764 HV *stash = gv_stashpv ("DC::OpenGL", 1);
1897 static const struct { 2765 static const struct {
1898 const char *name; 2766 const char *name;
1899 IV iv; 2767 IV iv;
1900 } *civ, const_iv[] = { 2768 } *civ, const_iv[] = {
1901# define const_iv(name) { # name, (IV)name } 2769# define const_iv(name) { # name, (IV)name }
2770 const_iv (GL_VENDOR),
2771 const_iv (GL_VERSION),
2772 const_iv (GL_EXTENSIONS),
1902 const_iv (GL_COLOR_MATERIAL), 2773 const_iv (GL_COLOR_MATERIAL),
1903 const_iv (GL_SMOOTH), 2774 const_iv (GL_SMOOTH),
1904 const_iv (GL_FLAT), 2775 const_iv (GL_FLAT),
1905 const_iv (GL_DITHER), 2776 const_iv (GL_DITHER),
1906 const_iv (GL_BLEND), 2777 const_iv (GL_BLEND),
… …
1910 const_iv (GL_ALPHA_TEST), 2781 const_iv (GL_ALPHA_TEST),
1911 const_iv (GL_NORMALIZE), 2782 const_iv (GL_NORMALIZE),
1912 const_iv (GL_RESCALE_NORMAL), 2783 const_iv (GL_RESCALE_NORMAL),
1913 const_iv (GL_FRONT), 2784 const_iv (GL_FRONT),
1914 const_iv (GL_BACK), 2785 const_iv (GL_BACK),
2786 const_iv (GL_AUX0),
1915 const_iv (GL_AND), 2787 const_iv (GL_AND),
1916 const_iv (GL_ONE), 2788 const_iv (GL_ONE),
1917 const_iv (GL_ZERO), 2789 const_iv (GL_ZERO),
1918 const_iv (GL_SRC_ALPHA), 2790 const_iv (GL_SRC_ALPHA),
1919 const_iv (GL_DST_ALPHA), 2791 const_iv (GL_DST_ALPHA),
… …
1932 const_iv (GL_INTENSITY), 2804 const_iv (GL_INTENSITY),
1933 const_iv (GL_LUMINANCE), 2805 const_iv (GL_LUMINANCE),
1934 const_iv (GL_LUMINANCE_ALPHA), 2806 const_iv (GL_LUMINANCE_ALPHA),
1935 const_iv (GL_FLOAT), 2807 const_iv (GL_FLOAT),
1936 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV), 2808 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
2809 const_iv (GL_COMPRESSED_ALPHA_ARB),
2810 const_iv (GL_COMPRESSED_LUMINANCE_ARB),
2811 const_iv (GL_COMPRESSED_LUMINANCE_ALPHA_ARB),
2812 const_iv (GL_COMPRESSED_INTENSITY_ARB),
2813 const_iv (GL_COMPRESSED_RGB_ARB),
2814 const_iv (GL_COMPRESSED_RGBA_ARB),
1937 const_iv (GL_COMPILE), 2815 const_iv (GL_COMPILE),
2816 const_iv (GL_PROXY_TEXTURE_1D),
2817 const_iv (GL_PROXY_TEXTURE_2D),
1938 const_iv (GL_TEXTURE_1D), 2818 const_iv (GL_TEXTURE_1D),
1939 const_iv (GL_TEXTURE_2D), 2819 const_iv (GL_TEXTURE_2D),
1940 const_iv (GL_TEXTURE_ENV), 2820 const_iv (GL_TEXTURE_ENV),
1941 const_iv (GL_TEXTURE_MAG_FILTER), 2821 const_iv (GL_TEXTURE_MAG_FILTER),
1942 const_iv (GL_TEXTURE_MIN_FILTER), 2822 const_iv (GL_TEXTURE_MIN_FILTER),
… …
1963 const_iv (GL_COLOR_LOGIC_OP), 2843 const_iv (GL_COLOR_LOGIC_OP),
1964 const_iv (GL_SEPARABLE_2D), 2844 const_iv (GL_SEPARABLE_2D),
1965 const_iv (GL_CONVOLUTION_2D), 2845 const_iv (GL_CONVOLUTION_2D),
1966 const_iv (GL_CONVOLUTION_BORDER_MODE), 2846 const_iv (GL_CONVOLUTION_BORDER_MODE),
1967 const_iv (GL_CONSTANT_BORDER), 2847 const_iv (GL_CONSTANT_BORDER),
2848 const_iv (GL_POINTS),
1968 const_iv (GL_LINES), 2849 const_iv (GL_LINES),
1969 const_iv (GL_LINE_STRIP), 2850 const_iv (GL_LINE_STRIP),
1970 const_iv (GL_LINE_LOOP), 2851 const_iv (GL_LINE_LOOP),
1971 const_iv (GL_QUADS), 2852 const_iv (GL_QUADS),
1972 const_iv (GL_QUAD_STRIP), 2853 const_iv (GL_QUAD_STRIP),
1973 const_iv (GL_TRIANGLES), 2854 const_iv (GL_TRIANGLES),
1974 const_iv (GL_TRIANGLE_STRIP), 2855 const_iv (GL_TRIANGLE_STRIP),
1975 const_iv (GL_TRIANGLE_FAN), 2856 const_iv (GL_TRIANGLE_FAN),
2857 const_iv (GL_POLYGON),
1976 const_iv (GL_PERSPECTIVE_CORRECTION_HINT), 2858 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2859 const_iv (GL_POINT_SMOOTH_HINT),
2860 const_iv (GL_LINE_SMOOTH_HINT),
2861 const_iv (GL_POLYGON_SMOOTH_HINT),
2862 const_iv (GL_GENERATE_MIPMAP_HINT),
2863 const_iv (GL_TEXTURE_COMPRESSION_HINT),
1977 const_iv (GL_FASTEST), 2864 const_iv (GL_FASTEST),
2865 const_iv (GL_DONT_CARE),
2866 const_iv (GL_NICEST),
1978 const_iv (GL_V2F), 2867 const_iv (GL_V2F),
1979 const_iv (GL_V3F), 2868 const_iv (GL_V3F),
1980 const_iv (GL_T2F_V3F), 2869 const_iv (GL_T2F_V3F),
1981 const_iv (GL_T2F_N3F_V3F), 2870 const_iv (GL_T2F_N3F_V3F),
1982# undef const_iv 2871# undef const_iv
1983 }; 2872 };
1984 2873
1985 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 2874 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1986 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 2875 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2876
2877 texture_av = newAV ();
2878 AvREAL_off (texture_av);
1987} 2879}
2880
2881void
2882disable_GL_EXT_blend_func_separate ()
2883 CODE:
2884 gl.BlendFuncSeparate = 0;
2885 gl.BlendFuncSeparateEXT = 0;
1988 2886
1989char * 2887char *
1990gl_vendor () 2888gl_vendor ()
1991 CODE: 2889 CODE:
1992 RETVAL = (char *)glGetString (GL_VENDOR); 2890 RETVAL = (char *)glGetString (GL_VENDOR);
… …
2005 CODE: 2903 CODE:
2006 RETVAL = (char *)glGetString (GL_EXTENSIONS); 2904 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2007 OUTPUT: 2905 OUTPUT:
2008 RETVAL 2906 RETVAL
2009 2907
2908const char *glGetString (GLenum pname)
2909
2910GLint glGetInteger (GLenum pname)
2911 CODE:
2912 glGetIntegerv (pname, &RETVAL);
2913 OUTPUT:
2914 RETVAL
2915
2916GLdouble glGetDouble (GLenum pname)
2917 CODE:
2918 glGetDoublev (pname, &RETVAL);
2919 OUTPUT:
2920 RETVAL
2921
2010int glGetError () 2922int glGetError ()
2011 2923
2012void glFinish () 2924void glFinish ()
2013 2925
2014void glClear (int mask) 2926void glClear (int mask)
… …
2051# near_ and far_ are due to microsofts buggy "c" compiler 2963# near_ and far_ are due to microsofts buggy "c" compiler
2052void glFrustum (double left, double right, double bottom, double top, double near_, double far_) 2964void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
2053 2965
2054# near_ and far_ are due to microsofts buggy "c" compiler 2966# near_ and far_ are due to microsofts buggy "c" compiler
2055void glOrtho (double left, double right, double bottom, double top, double near_, double far_) 2967void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2968
2969PROTOTYPES: DISABLE
2056 2970
2057void glViewport (int x, int y, int width, int height) 2971void glViewport (int x, int y, int width, int height)
2058 2972
2059void glScissor (int x, int y, int width, int height) 2973void glScissor (int x, int y, int width, int height)
2060 2974
… …
2068 2982
2069void glRotate (float angle, float x, float y, float z) 2983void glRotate (float angle, float x, float y, float z)
2070 CODE: 2984 CODE:
2071 glRotatef (angle, x, y, z); 2985 glRotatef (angle, x, y, z);
2072 2986
2073void glBegin (int mode)
2074
2075void glEnd ()
2076
2077void glColor (float r, float g, float b, float a = 1.0) 2987void glColor (float r, float g, float b, float a = 1.0)
2078 PROTOTYPE: @
2079 ALIAS: 2988 ALIAS:
2080 glColor_premultiply = 1 2989 glColor_premultiply = 1
2081 CODE: 2990 CODE:
2082 if (ix) 2991 if (ix)
2083 { 2992 {
… …
2086 b *= a; 2995 b *= a;
2087 } 2996 }
2088 // microsoft visual "c" rounds instead of truncating... 2997 // microsoft visual "c" rounds instead of truncating...
2089 glColor4f (r, g, b, a); 2998 glColor4f (r, g, b, a);
2090 2999
2091void glInterleavedArrays (int format, int stride, char *data)
2092
2093void glDrawElements (int mode, int count, int type, char *indices)
2094
2095# 1.2 void glDrawRangeElements (int mode, int start, int end
2096
2097void glRasterPos (float x, float y, float z = 0.) 3000void glRasterPos (float x, float y, float z = 0.)
2098 CODE: 3001 CODE:
2099 glRasterPos3f (0, 0, z); 3002 glRasterPos3f (0, 0, z);
2100 glBitmap (0, 0, 0, 0, x, y, 0); 3003 glBitmap (0, 0, 0, 0, x, y, 0);
2101 3004
… …
2105 3008
2106void glTexCoord (float s, float t) 3009void glTexCoord (float s, float t)
2107 CODE: 3010 CODE:
2108 glTexCoord2f (s, t); 3011 glTexCoord2f (s, t);
2109 3012
3013void glRect (float x1, float y1, float x2, float y2)
3014 CODE:
3015 glRectf (x1, y1, x2, y2);
3016
3017void glRect_lineloop (float x1, float y1, float x2, float y2)
3018 CODE:
3019 glBegin (GL_LINE_LOOP);
3020 glVertex2f (x1, y1);
3021 glVertex2f (x2, y1);
3022 glVertex2f (x2, y2);
3023 glVertex2f (x1, y2);
3024 glEnd ();
3025
3026PROTOTYPES: ENABLE
3027
3028void glBegin (int mode)
3029
3030void glEnd ()
3031
3032void glPointSize (GLfloat size)
3033
3034void glLineWidth (GLfloat width)
3035
3036void glInterleavedArrays (int format, int stride, char *data)
3037
3038void glDrawElements (int mode, int count, int type, char *indices)
3039
3040# 1.2 void glDrawRangeElements (int mode, int start, int end
3041
2110void glTexEnv (int target, int pname, float param) 3042void glTexEnv (int target, int pname, float param)
2111 CODE: 3043 CODE:
2112 glTexEnvf (target, pname, param); 3044 glTexEnvf (target, pname, param);
2113 3045
2114void glTexParameter (int target, int pname, float param) 3046void glTexParameter (int target, int pname, float param)
… …
2130void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column) 3062void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2131 CODE: 3063 CODE:
2132 if (gl.SeparableFilter2D) 3064 if (gl.SeparableFilter2D)
2133 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3065 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2134 3066
2135void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data) 3067void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data = 0)
2136 3068
2137void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 3069void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2138 3070
2139void glDrawPixels (int width, int height, int format, int type, char *pixels) 3071void glDrawPixels (int width, int height, int format, int type, char *pixels)
3072
3073void glPixelZoom (float x, float y)
2140 3074
2141void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 3075void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2142 3076
2143int glGenTexture () 3077int glGenTexture ()
2144 CODE: 3078 CODE:
2145{ 3079 RETVAL = gen_texture ();
2146 GLuint name;
2147 glGenTextures (1, &name);
2148 RETVAL = name;
2149}
2150 OUTPUT: 3080 OUTPUT:
2151 RETVAL 3081 RETVAL
2152 3082
2153void glDeleteTexture (int name) 3083void glDeleteTexture (int name)
2154 CODE: 3084 CODE:
2155{
2156 GLuint name_ = name;
2157 glDeleteTextures (1, &name_); 3085 del_texture (name);
2158} 3086
2159
2160int glGenList () 3087int glGenList ()
2161 CODE: 3088 CODE:
2162 RETVAL = glGenLists (1); 3089 RETVAL = glGenLists (1);
2163 OUTPUT: 3090 OUTPUT:
2164 RETVAL 3091 RETVAL
… …
2171 3098
2172void glEndList () 3099void glEndList ()
2173 3100
2174void glCallList (int list) 3101void glCallList (int list)
2175 3102
3103MODULE = Deliantra::Client PACKAGE = DC::UI::Base
3104
3105PROTOTYPES: DISABLE
3106
3107void
3108find_widget (SV *self, NV x, NV y)
3109 PPCODE:
3110{
3111 if (within_widget (self, x, y))
3112 XPUSHs (self);
3113}
3114
3115BOOT:
3116{
3117 hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
3118
3119 draw_x_gv = gv_fetchpv ("DC::UI::Base::draw_x", 1, SVt_NV);
3120 draw_y_gv = gv_fetchpv ("DC::UI::Base::draw_y", 1, SVt_NV);
3121 draw_w_gv = gv_fetchpv ("DC::UI::Base::draw_w", 1, SVt_NV);
3122 draw_h_gv = gv_fetchpv ("DC::UI::Base::draw_h", 1, SVt_NV);
3123}
3124
3125void
3126draw (SV *self)
3127 CODE:
3128{
3129 HV *hv;
3130 SV **svp;
3131 NV x, y, w, h;
3132 SV *draw_x_sv = GvSV (draw_x_gv);
3133 SV *draw_y_sv = GvSV (draw_y_gv);
3134 SV *draw_w_sv = GvSV (draw_w_gv);
3135 SV *draw_h_sv = GvSV (draw_h_gv);
3136 double draw_x, draw_y;
3137
3138 if (!SvROK (self))
3139 croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
3140
3141 hv = (HV *)SvRV (self);
3142
3143 if (SvTYPE (hv) != SVt_PVHV)
3144 croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
3145
3146 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
3147 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
3148
3149 if (!h || !w)
3150 XSRETURN_EMPTY;
3151
3152 svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
3153 svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
3154
3155 draw_x = SvNV (draw_x_sv) + x;
3156 draw_y = SvNV (draw_y_sv) + y;
3157
3158 if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
3159 || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
3160 XSRETURN_EMPTY;
3161
3162 sv_setnv (draw_x_sv, draw_x);
3163 sv_setnv (draw_y_sv, draw_y);
3164
3165 glPushMatrix ();
3166 glTranslated (x, y, 0);
3167
3168 if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
3169 {
3170 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
3171
3172 if (svp && SvTRUE (*svp))
3173 {
3174 glColor4f (1.0f * 0.2f, 0.8f * 0.2f, 0.5f * 0.2f, 0.2f);
3175 glEnable (GL_BLEND);
3176 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
3177 glBegin (GL_QUADS);
3178 glVertex2f (0, 0);
3179 glVertex2f (w, 0);
3180 glVertex2f (w, h);
3181 glVertex2f (0, h);
3182 glEnd ();
3183 glDisable (GL_BLEND);
3184 }
3185 }
3186#if 0
3187 // draw borders, for debugging
3188 glPushMatrix ();
3189 glColor4f (1., 1., 0., 1.);
3190 glTranslatef (.5, .5, 0.);
3191 glBegin (GL_LINE_LOOP);
3192 glVertex2f (0 , 0);
3193 glVertex2f (w - 1, 0);
3194 glVertex2f (w - 1, h - 1);
3195 glVertex2f (0 , h - 1);
3196 glEnd ();
3197 glPopMatrix ();
3198#endif
3199 PUSHMARK (SP);
3200 XPUSHs (self);
3201 PUTBACK;
3202 call_method ("_draw", G_VOID | G_DISCARD);
3203 SPAGAIN;
3204
3205 glPopMatrix ();
3206
3207 draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
3208 draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
3209}
3210

Diff Legend

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