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.240 by root, Wed Dec 26 18:09:30 2007 UTC vs.
Revision 1.329 by root, Sun Nov 18 13:07:51 2018 UTC

… …
15 15
16#include "EXTERN.h" 16#include "EXTERN.h"
17#include "perl.h" 17#include "perl.h"
18#include "XSUB.h" 18#include "XSUB.h"
19 19
20#include "flat_hash_map.hpp"
21
20#ifdef _WIN32 22#ifdef _WIN32
21# undef pipe 23# undef pipe
22// microsoft vs. C 24// microsoft vs. C
23# define sqrtf(x) sqrt(x) 25# define sqrtf(x) sqrt(x)
24# define roundf(x) (int)(x)
25# define atan2f(x,y) atan2(x,y) 26# define atan2f(x,y) atan2(x,y)
26# define M_PI 3.14159265f 27# define M_PI 3.14159265f
27#endif 28#endif
28 29
29#include <assert.h> 30#include <cassert>
30#include <math.h> 31#include <cmath>
31#include <string.h> 32#include <cstring>
32#include <stdio.h> 33#include <cstdio>
33#include <stdlib.h> 34#include <cstdlib>
35
36#include <utility>
37#include <bitset>
34 38
35#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW 39#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36 40
37#include <SDL.h> 41#include <SDL.h>
38#include <SDL_thread.h> 42#include <SDL_thread.h>
39#include <SDL_endian.h> 43#include <SDL_endian.h>
40#include <SDL_image.h> 44#include <SDL_image.h>
41#include <SDL_mixer.h> 45#include <SDL_mixer.h>
42#include <SDL_opengl.h> 46#include <SDL_opengl.h>
43 47
48/* work around os x broken headers */
49#ifdef __MACOSX__
50typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
51typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
52typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
53#endif
54
44#define PANGO_ENABLE_BACKEND 55#define PANGO_ENABLE_BACKEND
45#define G_DISABLE_CAST_CHECKS 56#define G_DISABLE_CAST_CHECKS
46 57
47#include <glib/gmacros.h> 58#include <glib.h>
48 59
49#include <pango/pango.h> 60#include <pango/pango.h>
61
62#ifndef PANGO_VERSION_CHECK
63# define PANGO_VERSION_CHECK(a,b,c) 0
64#endif
65
66#if !PANGO_VERSION_CHECK (1, 15, 2)
67# define pango_layout_get_line_readonly pango_layout_get_line
68# define pango_layout_get_lines_readonly pango_layout_get_lines
69# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line
70# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run
71#endif
50 72
51#ifndef _WIN32 73#ifndef _WIN32
52# include <sys/types.h> 74# include <sys/types.h>
53# include <sys/socket.h> 75# include <sys/socket.h>
54# include <netinet/in.h> 76# include <netinet/in.h>
55# include <netinet/tcp.h> 77# include <netinet/tcp.h>
56# include <inttypes.h> 78# include <inttypes.h>
57#endif 79#endif
58 80
81#if __GNUC__ >= 4
82# define expect(expr,value) __builtin_expect ((expr),(value))
83#else
84# define expect(expr,value) (expr)
85#endif
86
87#define expect_false(expr) expect ((expr) != 0, 0)
88#define expect_true(expr) expect ((expr) != 0, 1)
89
59#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */ 90#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
60 91
92/* this is used as fow flag as well, so has to have a different value */
93/* then anything that is computed by incoming darkness */
61#define FOW_DARKNESS 32 94#define FOW_DARKNESS 50
95#define DARKNESS_ADJUST(n) (n)
62 96
63#define MAP_EXTEND_X 32 97#define MAP_EXTEND_X 32
64#define MAP_EXTEND_Y 512 98#define MAP_EXTEND_Y 512
65 99
66#define MIN_FONT_HEIGHT 10 100#define MIN_FONT_HEIGHT 10
67 101
68#if 0 102/* mask out modifiers we are not interested in */
69# define PARACHUTE SDL_INIT_NOPARACHUTE 103#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
70#else 104
71# define PARACHUTE 0 105#define KMOD_LRAM 0x10000 // our extension
72#endif 106
107#define TEXID_SPEECH 1
108#define TEXID_NOFACE 2
109
110static char *
111fast_sv_grow (SV *sv, STRLEN need)
112{
113 STRLEN len = SvLEN (sv);
114 STRLEN want = SvCUR (sv) + need;
115
116 if (expect_false (len < want))
117 {
118 do
119 len *= 2;
120 while (len < want);
121
122 sv_grow (sv, len);
123 }
124
125 SvCUR_set (sv, want);
126 return SvEND (sv) - need;
127}
73 128
74static AV *texture_av; 129static AV *texture_av;
75 130
76static struct 131static struct
77{ 132{
… …
120 175
121#include "pango-font.c" 176#include "pango-font.c"
122#include "pango-fontmap.c" 177#include "pango-fontmap.c"
123#include "pango-render.c" 178#include "pango-render.c"
124 179
125typedef IV CFPlus__Channel; 180typedef IV DC__Channel;
126typedef SDL_RWops *CFPlus__RW; 181typedef SDL_RWops *DC__RW;
127typedef Mix_Chunk *CFPlus__MixChunk; 182typedef Mix_Chunk *DC__MixChunk;
128typedef Mix_Music *CFPlus__MixMusic; 183typedef Mix_Music *DC__MixMusic;
129 184
130typedef PangoFontDescription *CFPlus__Font; 185typedef PangoFontDescription *DC__Font;
131 186
132static int 187static int
133shape_attr_p (PangoLayoutRun *run) 188shape_attr_p (PangoLayoutRun *run)
134{ 189{
135 GSList *attrs = run->item->analysis.extra_attrs; 190 GSList *attrs = run->item->analysis.extra_attrs;
136 191
137 while (attrs) 192 while (attrs)
138 { 193 {
139 PangoAttribute *attr = attrs->data; 194 PangoAttribute *attr = (PangoAttribute *)attrs->data;
140 195
141 if (attr->klass->type == PANGO_ATTR_SHAPE) 196 if (attr->klass->type == PANGO_ATTR_SHAPE)
142 return 1; 197 return 1;
143 198
144 attrs = attrs->next; 199 attrs = attrs->next;
145 } 200 }
146 201
147 return 0; 202 return 0;
148} 203}
149 204
150typedef struct cf_layout { 205struct cf_layout {
151 PangoLayout *pl; 206 PangoLayout *pl;
152 float r, g, b, a; // default color for rgba mode 207 float r, g, b, a; // default color for rgba mode
153 int base_height; 208 int base_height;
154 CFPlus__Font font; 209 DC__Font font;
155 rc_t *rc; 210 rc_t rc;
156} *CFPlus__Layout; 211};
157 212
213typedef cf_layout *DC__Layout;
214
158static CFPlus__Font default_font; 215static DC__Font default_font;
159static PangoContext *opengl_context; 216static PangoContext *opengl_context;
160static PangoFontMap *opengl_fontmap; 217static PangoFontMap *opengl_fontmap;
161 218
162static void 219static void
163substitute_func (FcPattern *pattern, gpointer data) 220substitute_func (FcPattern *pattern, gpointer data)
164{ 221{
165 FcPatternAddBool (pattern, FC_HINTING, 1); 222 FcPatternAddBool (pattern, FC_HINTING, 1);
166#ifdef FC_HINT_STYLE 223#ifdef FC_HINT_STYLE
167 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL); 224 FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
168#endif 225#endif
169 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 226 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
170} 227}
171 228
172static void 229static void
173layout_update_font (CFPlus__Layout self) 230layout_update_font (DC__Layout self)
174{ 231{
175 /* use a random scale factor to account for unknown descenders, 0.8 works 232 /* use a random scale factor to account for unknown descenders, 0.8 works
176 * reasonably well with bitstream vera 233 * reasonably well with dejavu/bistream fonts
177 */ 234 */
178 PangoFontDescription *font = self->font ? self->font : default_font; 235 PangoFontDescription *font = self->font ? self->font : default_font;
179 236
180 pango_font_description_set_absolute_size (font, 237 pango_font_description_set_absolute_size (font,
181 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10)); 238 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
182 239
183 pango_layout_set_font_description (self->pl, font); 240 pango_layout_set_font_description (self->pl, font);
184} 241}
185 242
186static void 243static void
187layout_get_pixel_size (CFPlus__Layout self, int *w, int *h) 244layout_get_pixel_size (DC__Layout self, int *w, int *h)
188{ 245{
189 PangoRectangle rect; 246 PangoRectangle rect;
190 247
191 // get_pixel_* wrongly rounds down 248 // get_pixel_* wrongly rounds down
192 pango_layout_get_extents (self->pl, 0, &rect); 249 pango_layout_get_extents (self->pl, 0, &rect);
… …
202} 259}
203 260
204typedef uint16_t tileid; 261typedef uint16_t tileid;
205typedef uint16_t faceid; 262typedef uint16_t faceid;
206 263
207typedef struct { 264struct maptex
265{
208 GLuint name; 266 GLuint name;
209 int w, h; 267 int w, h;
210 float s, t; 268 float s, t;
211 uint8_t r, g, b, a; 269 uint8_t r, g, b, a;
212 tileid smoothtile; 270 tileid smoothtile;
213 uint8_t smoothlevel; 271 uint8_t smoothlevel;
214} maptex; 272 uint8_t unused; /* set to zero on use */
273};
215 274
216typedef struct { 275struct mapcell
276{
217 uint32_t player; 277 uint32_t player;
218 tileid tile[3]; 278 tileid tile[3];
219 uint16_t darkness; 279 uint16_t darkness;
220 uint8_t stat_width, stat_hp, flags, smoothmax; 280 uint8_t stat_width, stat_hp, flags, smoothmax;
221} mapcell; 281};
222 282
223typedef struct { 283struct maprow
284{
224 int32_t c0, c1; 285 int32_t c0, c1;
225 mapcell *col; 286 mapcell *col;
226} maprow; 287};
227 288
228typedef struct map { 289struct mapgrid {
229 int x, y, w, h; 290 int x, y, w, h;
230 int ox, oy; /* offset to virtual global coordinate system */ 291 int ox, oy; /* offset to virtual global coordinate system */
231 int faces; tileid *face2tile; // [faceid] 292 int faces; tileid *face2tile; // [faceid]
232 int texs; maptex *tex; // [tileid] 293 int texs; maptex *tex; // [tileid]
233 294
234 int32_t rows; 295 int32_t rows;
235 maprow *row; 296 maprow *row;
236} *CFPlus__Map; 297};
237 298
238static char * 299typedef mapgrid *DC__Map;
300
301template<typename T>
302static void
239prepend (char *ptr, int sze, int inc) 303prepend (T *&ptr, int sze, int inc)
240{ 304{
241 char *p; 305 T *p;
242 306
243 New (0, p, sze + inc, char); 307 New (0, p, sze + inc, T);
244 Zero (p, inc, char); 308 Zero (p, inc, T);
245 Move (ptr, p + inc, sze, char); 309 Move (ptr, p + inc, sze, T);
246 Safefree (ptr); 310 Safefree (ptr);
247 311
248 return p; 312 ptr = p;
249} 313}
250 314
251static char * 315template<typename T>
252append (char *ptr, int sze, int inc)
253{
254 Renew (ptr, sze + inc, char);
255 Zero (ptr + sze, inc, char);
256
257 return ptr;
258}
259
260#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
261#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
262
263static void 316static void
317append (T *&ptr, int sze, int inc)
318{
319 Renew (ptr, sze + inc, T);
320 Zero (ptr + sze, inc, T);
321}
322
323static void
264need_facenum (struct map *self, faceid face) 324need_facenum (struct mapgrid *self, faceid face)
265{ 325{
266 while (self->faces <= face) 326 while (self->faces <= face)
267 { 327 {
268 Append (tileid, self->face2tile, self->faces, self->faces); 328 append (self->face2tile, self->faces, self->faces);
269 self->faces *= 2; 329 self->faces *= 2;
270 } 330 }
271} 331}
272 332
273static void 333static void
274need_texid (struct map *self, int texid) 334need_texid (struct mapgrid *self, int texid)
275{ 335{
276 while (self->texs <= texid) 336 while (self->texs <= texid)
277 { 337 {
278 Append (maptex, self->tex, self->texs, self->texs); 338 append (self->tex, self->texs, self->texs);
279 self->texs *= 2; 339 self->texs *= 2;
280 } 340 }
281} 341}
282 342
283static maprow * 343static maprow *
284map_get_row (CFPlus__Map self, int y) 344map_get_row (mapgrid *self, int y)
285{ 345{
286 if (0 > y) 346 if (0 > y)
287 { 347 {
288 int extend = - y + MAP_EXTEND_Y; 348 int extend = - y + MAP_EXTEND_Y;
289 Prepend (maprow, self->row, self->rows, extend); 349 prepend (self->row, self->rows, extend);
290 350
291 self->rows += extend; 351 self->rows += extend;
292 self->y += extend; 352 self->y += extend;
293 y += extend; 353 y += extend;
294 } 354 }
295 else if (y >= self->rows) 355 else if (y >= self->rows)
296 { 356 {
297 int extend = y - self->rows + MAP_EXTEND_Y; 357 int extend = y - self->rows + MAP_EXTEND_Y;
298 Append (maprow, self->row, self->rows, extend); 358 append (self->row, self->rows, extend);
299 self->rows += extend; 359 self->rows += extend;
300 } 360 }
301 361
302 return self->row + y; 362 return self->row + y;
303} 363}
… …
313 } 373 }
314 374
315 if (row->c0 > x) 375 if (row->c0 > x)
316 { 376 {
317 int extend = row->c0 - x + MAP_EXTEND_X; 377 int extend = row->c0 - x + MAP_EXTEND_X;
318 Prepend (mapcell, row->col, row->c1 - row->c0, extend); 378 prepend (row->col, row->c1 - row->c0, extend);
319 row->c0 -= extend; 379 row->c0 -= extend;
320 } 380 }
321 else if (x >= row->c1) 381 else if (x >= row->c1)
322 { 382 {
323 int extend = x - row->c1 + MAP_EXTEND_X; 383 int extend = x - row->c1 + MAP_EXTEND_X;
324 Append (mapcell, row->col, row->c1 - row->c0, extend); 384 append (row->col, row->c1 - row->c0, extend);
325 row->c1 += extend; 385 row->c1 += extend;
326 } 386 }
327 387
328 return row->col + (x - row->c0); 388 return row->col + (x - row->c0);
329} 389}
330 390
331static mapcell * 391static mapcell *
332map_get_cell (CFPlus__Map self, int x, int y) 392map_get_cell (mapgrid *self, int x, int y)
333{ 393{
334 return row_get_cell (map_get_row (self, y), x); 394 return row_get_cell (map_get_row (self, y), x);
335} 395}
336 396
337static void 397static void
338map_clear (CFPlus__Map self) 398map_clear (mapgrid *self)
339{ 399{
340 int r; 400 int r;
341 401
342 for (r = 0; r < self->rows; r++) 402 for (r = 0; r < self->rows; r++)
343 Safefree (self->row[r].col); 403 Safefree (self->row[r].col);
… …
350 self->oy = 0; 410 self->oy = 0;
351 self->row = 0; 411 self->row = 0;
352 self->rows = 0; 412 self->rows = 0;
353} 413}
354 414
415#define CELL_CLEAR(cell) \
416 do { \
417 if ((cell)->player) \
418 (cell)->tile [2] = 0; \
419 (cell)->darkness = 0; \
420 (cell)->stat_hp = 0; \
421 (cell)->flags = 0; \
422 (cell)->player = 0; \
423 } while (0)
424
355static void 425static void
356map_blank (CFPlus__Map self, int x0, int y0, int w, int h) 426map_blank (mapgrid *self, int x0, int y0, int w, int h)
357{ 427{
358 int x, y; 428 int x, y;
359 maprow *row; 429 maprow *row;
360 mapcell *cell; 430 mapcell *cell;
361 431
… …
373 if (x >= row->c1) 443 if (x >= row->c1)
374 break; 444 break;
375 445
376 cell = row->col + x - row->c0; 446 cell = row->col + x - row->c0;
377 447
378 cell->darkness = 0; 448 CELL_CLEAR (cell);
379 cell->stat_hp = 0;
380 cell->flags = 0;
381 cell->player = 0;
382 } 449 }
383 } 450 }
384} 451}
385 452
386typedef struct { 453struct smooth_key
454{
387 tileid tile; 455 tileid tile;
388 uint8_t x, y, level; 456 uint8_t x, y, level;
389} smooth_key; 457
458 bool operator == (const smooth_key &o) const
459 {
460 return tile == o.tile && x == o.x && y == o.y && level == o.level;
461 }
462};
463
464typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
465
466namespace std {
467 template <>
468 struct hash<smooth_key>
469 {
470 size_t operator () (const smooth_key &v) const
471 {
472 return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
473 }
474 };
475}
390 476
391static void 477static void
392smooth_or_bits (HV *hv, smooth_key *key, IV bits) 478smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
393{ 479{
394 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1); 480 auto &&it = h.find (key);
395 481
396 if (SvIOK (*sv)) 482 if (it == h.end ())
397 SvIV_set (*sv, SvIVX (*sv) | bits); 483 h.insert (std::make_pair (key, bits));
398 else 484 else
399 sv_setiv (*sv, bits); 485 it->second |= bits;
400} 486}
401 487
402static void 488static void
403music_finished (void) 489music_finished (void)
404{ 490{
… …
421 ev.code = 1; 507 ev.code = 1;
422 ev.data1 = (void *)(long)channel; 508 ev.data1 = (void *)(long)channel;
423 ev.data2 = 0; 509 ev.data2 = 0;
424 510
425 SDL_PushEvent ((SDL_Event *)&ev); 511 SDL_PushEvent ((SDL_Event *)&ev);
512}
513
514// approximately divide by 255
515static unsigned int
516div255 (unsigned int n)
517{
518 return (n + (n >> 8)) >> 8;
426} 519}
427 520
428static unsigned int 521static unsigned int
429minpot (unsigned int n) 522minpot (unsigned int n)
430{ 523{
… …
498 return 0; 591 return 0;
499 592
500 return 1; 593 return 1;
501} 594}
502 595
503MODULE = CFPlus PACKAGE = CFPlus 596/******************************************************************************/
597
598/* process keyboard modifiers */
599static int
600mod_munge (int mod)
601{
602 mod &= MOD_MASK;
603
604 if (mod & (KMOD_META | KMOD_ALT))
605 mod |= KMOD_LRAM;
606
607 return mod;
608}
609
610static void
611deliantra_main (SV *real_main)
612{
613 dSP;
614
615 PUSHMARK (SP);
616 call_sv (real_main, G_DISCARD | G_VOID);
617}
618
619#ifdef __MACOSX__
620 static SV *real_main;
621
622 /* to due surprising braindamage on the side of SDL design, we
623 * do some mind-boggling hack here: SDL requires a custom main()
624 * on OS X, so... we provide one and call the original main(), which,
625 * due to shared library magic, calls -lSDLmain's main, not perl's main,
626 * and which calls our main (== SDL_main) back.
627 */
628 extern C_LINKAGE int
629 main (int argc, char *argv[])
630 {
631 deliantra_main (real_main);
632 }
633
634 #undef main
635
636 extern C_LINKAGE int main (int argc, char *argv[]);
637
638 static void
639 SDL_main_hack (SV *real_main_)
640 {
641 real_main = real_main_;
642
643 char *argv[] = { "deliantra client", 0 };
644 (main) (1, argv);
645 }
646#else
647 static void
648 SDL_main_hack (SV *real_main)
649 {
650 deliantra_main (real_main);
651 }
652#endif
653
654MODULE = Deliantra::Client PACKAGE = DC
504 655
505PROTOTYPES: ENABLE 656PROTOTYPES: ENABLE
506 657
507BOOT: 658BOOT:
508{ 659{
509 HV *stash = gv_stashpv ("CFPlus", 1); 660 HV *stash = gv_stashpv ("DC", 1);
510 static const struct { 661 static const struct {
511 const char *name; 662 const char *name;
512 IV iv; 663 IV iv;
513 } *civ, const_iv[] = { 664 } *civ, const_iv[] = {
514# define const_iv(name) { # name, (IV)name } 665# define const_iv(name) { # name, (IV)name }
… …
535 const_iv (SDL_USEREVENT), 686 const_iv (SDL_USEREVENT),
536 687
537 const_iv (SDL_APPINPUTFOCUS), 688 const_iv (SDL_APPINPUTFOCUS),
538 const_iv (SDL_APPMOUSEFOCUS), 689 const_iv (SDL_APPMOUSEFOCUS),
539 const_iv (SDL_APPACTIVE), 690 const_iv (SDL_APPACTIVE),
691
692
693 const_iv (SDLK_UNKNOWN),
694 const_iv (SDLK_FIRST),
695 const_iv (SDLK_BACKSPACE),
696 const_iv (SDLK_TAB),
697 const_iv (SDLK_CLEAR),
698 const_iv (SDLK_RETURN),
699 const_iv (SDLK_PAUSE),
700 const_iv (SDLK_ESCAPE),
701 const_iv (SDLK_SPACE),
702 const_iv (SDLK_EXCLAIM),
703 const_iv (SDLK_QUOTEDBL),
704 const_iv (SDLK_HASH),
705 const_iv (SDLK_DOLLAR),
706 const_iv (SDLK_AMPERSAND),
707 const_iv (SDLK_QUOTE),
708 const_iv (SDLK_LEFTPAREN),
709 const_iv (SDLK_RIGHTPAREN),
710 const_iv (SDLK_ASTERISK),
711 const_iv (SDLK_PLUS),
712 const_iv (SDLK_COMMA),
713 const_iv (SDLK_MINUS),
714 const_iv (SDLK_PERIOD),
715 const_iv (SDLK_SLASH),
716 const_iv (SDLK_0),
717 const_iv (SDLK_1),
718 const_iv (SDLK_2),
719 const_iv (SDLK_3),
720 const_iv (SDLK_4),
721 const_iv (SDLK_5),
722 const_iv (SDLK_6),
723 const_iv (SDLK_7),
724 const_iv (SDLK_8),
725 const_iv (SDLK_9),
726 const_iv (SDLK_COLON),
727 const_iv (SDLK_SEMICOLON),
728 const_iv (SDLK_LESS),
729 const_iv (SDLK_EQUALS),
730 const_iv (SDLK_GREATER),
731 const_iv (SDLK_QUESTION),
732 const_iv (SDLK_AT),
733
734 const_iv (SDLK_LEFTBRACKET),
735 const_iv (SDLK_BACKSLASH),
736 const_iv (SDLK_RIGHTBRACKET),
737 const_iv (SDLK_CARET),
738 const_iv (SDLK_UNDERSCORE),
739 const_iv (SDLK_BACKQUOTE),
740 const_iv (SDLK_DELETE),
540 741
541 const_iv (SDLK_FIRST), 742 const_iv (SDLK_FIRST),
542 const_iv (SDLK_LAST), 743 const_iv (SDLK_LAST),
543 const_iv (SDLK_KP0), 744 const_iv (SDLK_KP0),
544 const_iv (SDLK_KP1), 745 const_iv (SDLK_KP1),
… …
620 const_iv (KMOD_RMETA), 821 const_iv (KMOD_RMETA),
621 const_iv (KMOD_NUM), 822 const_iv (KMOD_NUM),
622 const_iv (KMOD_CAPS), 823 const_iv (KMOD_CAPS),
623 const_iv (KMOD_MODE), 824 const_iv (KMOD_MODE),
624 825
826 const_iv (KMOD_LRAM),
827
625 const_iv (MIX_DEFAULT_FORMAT), 828 const_iv (MIX_DEFAULT_FORMAT),
829
830 const_iv (SDL_INIT_TIMER),
831 const_iv (SDL_INIT_AUDIO),
832 const_iv (SDL_INIT_VIDEO),
833 const_iv (SDL_INIT_CDROM),
834 const_iv (SDL_INIT_JOYSTICK),
835 const_iv (SDL_INIT_EVERYTHING),
836 const_iv (SDL_INIT_NOPARACHUTE),
837 const_iv (SDL_INIT_EVENTTHREAD),
838
839 const_iv (SDL_GL_RED_SIZE),
840 const_iv (SDL_GL_GREEN_SIZE),
841 const_iv (SDL_GL_BLUE_SIZE),
842 const_iv (SDL_GL_ALPHA_SIZE),
843 const_iv (SDL_GL_DOUBLEBUFFER),
844 const_iv (SDL_GL_BUFFER_SIZE),
845 const_iv (SDL_GL_DEPTH_SIZE),
846 const_iv (SDL_GL_STENCIL_SIZE),
847 const_iv (SDL_GL_ACCUM_RED_SIZE),
848 const_iv (SDL_GL_ACCUM_GREEN_SIZE),
849 const_iv (SDL_GL_ACCUM_BLUE_SIZE),
850 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
851 const_iv (SDL_GL_STEREO),
852 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
853 const_iv (SDL_GL_MULTISAMPLESAMPLES),
854 const_iv (SDL_GL_ACCELERATED_VISUAL),
855 const_iv (SDL_GL_SWAP_CONTROL),
856
857 const_iv (FOW_DARKNESS)
626# undef const_iv 858# undef const_iv
627 }; 859 };
628 860
629 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 861 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
630 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 862 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
631 863
632 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK); 864 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
633 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE); 865 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
634} 866}
635 867
… …
651NV ceil (NV x) 883NV ceil (NV x)
652 884
653IV minpot (UV n) 885IV minpot (UV n)
654 886
655IV popcount (UV n) 887IV popcount (UV n)
888
889NV distance (NV dx, NV dy)
890 CODE:
891 RETVAL = pow (dx * dx + dy * dy, 0.5);
892 OUTPUT:
893 RETVAL
656 894
657void 895void
658pango_init () 896pango_init ()
659 CODE: 897 CODE:
660{ 898{
661 opengl_fontmap = pango_opengl_font_map_new (); 899 opengl_fontmap = pango_opengl_font_map_new ();
662 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 900 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
663 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 901 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
902 /*pango_context_set_font_description (opengl_context, default_font);*/
903#if PANGO_VERSION_CHECK (1, 15, 2)
904 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
905 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
906#endif
664} 907}
665 908
666char *
667SDL_GetError () 909char *SDL_GetError ()
668 910
669int 911void SDL_main_hack (SV *real_main)
670SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 912 PROTOTYPE: &
671 913
672void 914int SDL_Init (U32 flags)
915
916int SDL_InitSubSystem (U32 flags)
917
918void SDL_QuitSubSystem (U32 flags)
919
673SDL_Quit () 920void SDL_Quit ()
921
922int SDL_GL_SetAttribute (int attr, int value)
923 C_ARGS: (SDL_GLattr)attr, value
924
925int SDL_GL_GetAttribute (int attr)
926 CODE:
927 if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
928 XSRETURN_UNDEF;
929 OUTPUT:
930 RETVAL
674 931
675void 932void
676SDL_ListModes (int rgb, int alpha) 933SDL_ListModes (int rgb, int alpha)
677 PPCODE: 934 PPCODE:
678{ 935{
… …
690 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 947 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
691 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0); 948 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
692 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 949 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
693 950
694 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 951 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
695#if SDL_VERSION_ATLEAST(1,2,10)
696 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
697 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 952 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
698#endif
699 953
700 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 954 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
701 955
702 if (m && m != (SDL_Rect **)-1) 956 if (m && m != (SDL_Rect **)-1)
703 while (*m) 957 while (*m)
704 { 958 {
705 if ((*m)->w >= 800 && (*m)->h >= 600) 959 if ((*m)->w >= 400 && (*m)->h >= 300)
706 { 960 {
707 AV *av = newAV (); 961 AV *av = newAV ();
708 av_push (av, newSViv ((*m)->w)); 962 av_push (av, newSViv ((*m)->w));
709 av_push (av, newSViv ((*m)->h)); 963 av_push (av, newSViv ((*m)->h));
710 av_push (av, newSViv (rgb)); 964 av_push (av, newSViv (rgb));
… …
733 ); 987 );
734 988
735 if (RETVAL) 989 if (RETVAL)
736 { 990 {
737 av_clear (texture_av); 991 av_clear (texture_av);
738
739 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
740#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 992#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
741#include "glfunc.h" 993#include "glfunc.h"
742#undef GL_FUNC 994#undef GL_FUNC
995 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
996 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
743 } 997 }
744} 998}
745 OUTPUT: 999 OUTPUT:
746 RETVAL 1000 RETVAL
1001
1002void
1003SDL_WM_SetCaption (const char *title, const char *icon)
747 1004
748void 1005void
749SDL_GL_SwapBuffers () 1006SDL_GL_SwapBuffers ()
750 1007
751char * 1008char *
752SDL_GetKeyName (int sym) 1009SDL_GetKeyName (int sym)
1010 C_ARGS: (SDLKey)sym
753 1011
754int 1012int
755SDL_GetAppState () 1013SDL_GetAppState ()
756 1014
1015int
1016SDL_GetModState ()
1017
1018int
1019SDL_WaitEvent ()
1020 C_ARGS: 0
1021
757void 1022void
1023SDL_PumpEvents ()
1024
1025void
758poll_events () 1026peep_events ()
759 PPCODE: 1027 PPCODE:
760{ 1028{
761 SDL_Event ev; 1029 SDL_Event ev;
762 1030
763 SDL_PumpEvents (); 1031 SDL_PumpEvents ();
… …
770 { 1038 {
771 case SDL_KEYDOWN: 1039 case SDL_KEYDOWN:
772 case SDL_KEYUP: 1040 case SDL_KEYUP:
773 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 1041 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
774 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 1042 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
775 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 1043 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
776 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */ 1044 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
777 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 1045 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
778 break; 1046 break;
779 1047
780 case SDL_ACTIVEEVENT: 1048 case SDL_ACTIVEEVENT:
781 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 1049 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
799 x = ev.motion.x; 1067 x = ev.motion.x;
800 y = ev.motion.y; 1068 y = ev.motion.y;
801 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 1069 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
802 } 1070 }
803 1071
804 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1072 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
805 hv_store (hv, "state", 5, newSViv (state), 0); 1073 hv_store (hv, "state", 5, newSViv (state), 0);
806 hv_store (hv, "x", 1, newSViv (x), 0); 1074 hv_store (hv, "x", 1, newSViv (x), 0);
807 hv_store (hv, "y", 1, newSViv (y), 0); 1075 hv_store (hv, "y", 1, newSViv (y), 0);
808 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1076 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
809 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1077 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
810 } 1078 }
811 break; 1079 break;
812 1080
813 case SDL_MOUSEBUTTONDOWN: 1081 case SDL_MOUSEBUTTONDOWN:
814 case SDL_MOUSEBUTTONUP: 1082 case SDL_MOUSEBUTTONUP:
815 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1083 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
816 1084
817 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 1085 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
818 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 1086 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
819 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 1087 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
820 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 1088 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
… …
825 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 1093 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
826 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 1094 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
827 break; 1095 break;
828 } 1096 }
829 1097
830 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1)))); 1098 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
831 } 1099 }
832} 1100}
1101
1102char *
1103SDL_AudioDriverName ()
1104 CODE:
1105{
1106 char buf [256];
1107 if (!SDL_AudioDriverName (buf, sizeof (buf)))
1108 XSRETURN_UNDEF;
1109
1110 RETVAL = buf;
1111}
1112 OUTPUT:
1113 RETVAL
833 1114
834int 1115int
835Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096) 1116Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
836 POSTCALL: 1117 POSTCALL:
837 Mix_HookMusicFinished (music_finished); 1118 Mix_HookMusicFinished (music_finished);
838 Mix_ChannelFinished (channel_finished); 1119 Mix_ChannelFinished (channel_finished);
839 1120
840void 1121void
841Mix_QuerySpec () 1122Mix_QuerySpec ()
… …
894 } 1175 }
895 } 1176 }
896#endif 1177#endif
897} 1178}
898 1179
899void 1180int
900add_font (char *file) 1181add_font (char *file)
901 CODE: 1182 CODE:
902 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1183 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1184 OUTPUT:
1185 RETVAL
1186
1187void
1188IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
1189
1190# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
1191void
1192Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
903 1193
904void 1194void
905load_image_inline (SV *image_) 1195load_image_inline (SV *image_)
906 ALIAS: 1196 ALIAS:
907 load_image_file = 1 1197 load_image_file = 1
… …
953 1243
954 SDL_LockSurface (surface2); 1244 SDL_LockSurface (surface2);
955 EXTEND (SP, 6); 1245 EXTEND (SP, 6);
956 PUSHs (sv_2mortal (newSViv (surface2->w))); 1246 PUSHs (sv_2mortal (newSViv (surface2->w)));
957 PUSHs (sv_2mortal (newSViv (surface2->h))); 1247 PUSHs (sv_2mortal (newSViv (surface2->h)));
958 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1248 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
959 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 1249 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
960 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1250 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
961 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1251 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
962 SDL_UnlockSurface (surface2); 1252 SDL_UnlockSurface (surface2);
963 1253
… …
1023#if DEBUG 1313#if DEBUG
1024 VALGRIND_DO_LEAK_CHECK; 1314 VALGRIND_DO_LEAK_CHECK;
1025#endif 1315#endif
1026} 1316}
1027 1317
1028MODULE = CFPlus PACKAGE = CFPlus::Font 1318int
1319SvREFCNT (SV *sv)
1320 CODE:
1321 RETVAL = SvREFCNT (sv);
1322 OUTPUT:
1323 RETVAL
1324
1325MODULE = Deliantra::Client PACKAGE = DC::Font
1029 1326
1030PROTOTYPES: DISABLE 1327PROTOTYPES: DISABLE
1031 1328
1032CFPlus::Font 1329DC::Font
1033new_from_file (SV *class, char *path, int id = 0) 1330new_from_file (SV *klass, char *path, int id = 0)
1034 CODE: 1331 CODE:
1035{ 1332{
1036 int count; 1333 int count;
1037 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1334 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1038 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1335 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1040} 1337}
1041 OUTPUT: 1338 OUTPUT:
1042 RETVAL 1339 RETVAL
1043 1340
1044void 1341void
1045DESTROY (CFPlus::Font self) 1342DESTROY (DC::Font self)
1046 CODE: 1343 CODE:
1047 pango_font_description_free (self); 1344 pango_font_description_free (self);
1048 1345
1049void 1346void
1050make_default (CFPlus::Font self) 1347make_default (DC::Font self)
1051 PROTOTYPE: $ 1348 PROTOTYPE: $
1052 CODE: 1349 CODE:
1053 default_font = self; 1350 default_font = self;
1054 1351
1055MODULE = CFPlus PACKAGE = CFPlus::Layout 1352MODULE = Deliantra::Client PACKAGE = DC::Layout
1056 1353
1057PROTOTYPES: DISABLE 1354PROTOTYPES: DISABLE
1058 1355
1059void 1356void
1060glyph_cache_backup () 1357glyph_cache_backup ()
… …
1066glyph_cache_restore () 1363glyph_cache_restore ()
1067 PROTOTYPE: 1364 PROTOTYPE:
1068 CODE: 1365 CODE:
1069 tc_restore (); 1366 tc_restore ();
1070 1367
1071CFPlus::Layout 1368DC::Layout
1072new (SV *class) 1369new (SV *klass)
1073 CODE: 1370 CODE:
1074 New (0, RETVAL, 1, struct cf_layout); 1371 RETVAL = new cf_layout;
1075 1372
1076 RETVAL->pl = pango_layout_new (opengl_context); 1373 RETVAL->pl = pango_layout_new (opengl_context);
1077 RETVAL->r = 1.; 1374 RETVAL->r = 1.;
1078 RETVAL->g = 1.; 1375 RETVAL->g = 1.;
1079 RETVAL->b = 1.; 1376 RETVAL->b = 1.;
1080 RETVAL->a = 1.; 1377 RETVAL->a = 1.;
1081 RETVAL->base_height = MIN_FONT_HEIGHT; 1378 RETVAL->base_height = MIN_FONT_HEIGHT;
1082 RETVAL->font = 0; 1379 RETVAL->font = 0;
1083 RETVAL->rc = rc_alloc ();
1084 1380
1085 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1381 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1086 layout_update_font (RETVAL); 1382 layout_update_font (RETVAL);
1087 OUTPUT: 1383 OUTPUT:
1088 RETVAL 1384 RETVAL
1089 1385
1090void 1386void
1091DESTROY (CFPlus::Layout self) 1387DESTROY (DC::Layout self)
1092 CODE: 1388 CODE:
1093 g_object_unref (self->pl); 1389 g_object_unref (self->pl);
1094 rc_free (self->rc);
1095 Safefree (self); 1390 delete self;
1096 1391
1097void 1392void
1098set_text (CFPlus::Layout self, SV *text_) 1393set_text (DC::Layout self, SV *text_)
1099 CODE: 1394 CODE:
1100{ 1395{
1101 STRLEN textlen; 1396 STRLEN textlen;
1102 char *text = SvPVutf8 (text_, textlen); 1397 char *text = SvPVutf8 (text_, textlen);
1103 1398
1104 pango_layout_set_text (self->pl, text, textlen); 1399 pango_layout_set_text (self->pl, text, textlen);
1105} 1400}
1106 1401
1107void 1402void
1108set_markup (CFPlus::Layout self, SV *text_) 1403set_markup (DC::Layout self, SV *text_)
1109 CODE: 1404 CODE:
1110{ 1405{
1111 STRLEN textlen; 1406 STRLEN textlen;
1112 char *text = SvPVutf8 (text_, textlen); 1407 char *text = SvPVutf8 (text_, textlen);
1113 1408
1114 pango_layout_set_markup (self->pl, text, textlen); 1409 pango_layout_set_markup (self->pl, text, textlen);
1115} 1410}
1116 1411
1117void 1412void
1118set_shapes (CFPlus::Layout self, ...) 1413set_shapes (DC::Layout self, ...)
1119 CODE: 1414 CODE:
1120{ 1415{
1121 PangoAttrList *attrs = 0; 1416 PangoAttrList *attrs = 0;
1122 const char *text = pango_layout_get_text (self->pl); 1417 const char *text = pango_layout_get_text (self->pl);
1123 const char *pos = text; 1418 const char *pos = text;
… …
1158 if (attrs) 1453 if (attrs)
1159 pango_layout_set_attributes (self->pl, attrs); 1454 pango_layout_set_attributes (self->pl, attrs);
1160} 1455}
1161 1456
1162void 1457void
1163get_shapes (CFPlus::Layout self) 1458get_shapes (DC::Layout self)
1164 PPCODE: 1459 PPCODE:
1165{ 1460{
1166 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1461 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1167 1462
1168 do 1463 do
1169 { 1464 {
1170 PangoLayoutRun *run = pango_layout_iter_get_run (iter); 1465 PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
1171 1466
1172 if (run && shape_attr_p (run)) 1467 if (run && shape_attr_p (run))
1173 { 1468 {
1174 PangoRectangle extents; 1469 PangoRectangle extents;
1175 pango_layout_iter_get_run_extents (iter, 0, &extents); 1470 pango_layout_iter_get_run_extents (iter, 0, &extents);
… …
1183 1478
1184 pango_layout_iter_free (iter); 1479 pango_layout_iter_free (iter);
1185} 1480}
1186 1481
1187int 1482int
1188has_wrapped (CFPlus::Layout self) 1483has_wrapped (DC::Layout self)
1189 CODE: 1484 CODE:
1190{ 1485{
1191 int lines = 1; 1486 int lines = 1;
1192 const char *text = pango_layout_get_text (self->pl); 1487 const char *text = pango_layout_get_text (self->pl);
1193 1488
… …
1198} 1493}
1199 OUTPUT: 1494 OUTPUT:
1200 RETVAL 1495 RETVAL
1201 1496
1202SV * 1497SV *
1203get_text (CFPlus::Layout self) 1498get_text (DC::Layout self)
1204 CODE: 1499 CODE:
1205 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1500 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1206 sv_utf8_decode (RETVAL); 1501 sv_utf8_decode (RETVAL);
1207 OUTPUT: 1502 OUTPUT:
1208 RETVAL 1503 RETVAL
1209 1504
1210void 1505void
1211set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.) 1506set_foreground (DC::Layout self, float r, float g, float b, float a = 1.)
1212 CODE: 1507 CODE:
1213 self->r = r; 1508 self->r = r;
1214 self->g = g; 1509 self->g = g;
1215 self->b = b; 1510 self->b = b;
1216 self->a = a; 1511 self->a = a;
1217 1512
1218void 1513void
1219set_font (CFPlus::Layout self, CFPlus::Font font = 0) 1514set_font (DC::Layout self, DC::Font font = 0)
1220 CODE: 1515 CODE:
1221 if (self->font != font) 1516 if (self->font != font)
1222 { 1517 {
1223 self->font = font; 1518 self->font = font;
1224 layout_update_font (self); 1519 layout_update_font (self);
1225 } 1520 }
1226 1521
1227void 1522void
1228set_height (CFPlus::Layout self, int base_height) 1523set_height (DC::Layout self, int base_height)
1229 CODE: 1524 CODE:
1230 if (self->base_height != base_height) 1525 if (self->base_height != base_height)
1231 { 1526 {
1232 self->base_height = base_height; 1527 self->base_height = base_height;
1233 layout_update_font (self); 1528 layout_update_font (self);
1234 } 1529 }
1235 1530
1236void 1531void
1237set_width (CFPlus::Layout self, int max_width = -1) 1532set_width (DC::Layout self, int max_width = -1)
1238 CODE: 1533 CODE:
1239 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1534 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
1240 1535
1241void 1536void
1242set_indent (CFPlus::Layout self, int indent) 1537set_indent (DC::Layout self, int indent)
1243 CODE: 1538 CODE:
1244 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1539 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1245 1540
1246void 1541void
1247set_spacing (CFPlus::Layout self, int spacing) 1542set_spacing (DC::Layout self, int spacing)
1248 CODE: 1543 CODE:
1249 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1544 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1250 1545
1251void 1546void
1252set_ellipsise (CFPlus::Layout self, int ellipsise) 1547set_ellipsise (DC::Layout self, int ellipsise)
1253 CODE: 1548 CODE:
1254 pango_layout_set_ellipsize (self->pl, 1549 pango_layout_set_ellipsize (self->pl,
1255 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1550 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1256 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1551 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1257 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1552 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1258 : PANGO_ELLIPSIZE_NONE 1553 : PANGO_ELLIPSIZE_NONE
1259 ); 1554 );
1260 1555
1261void 1556void
1262set_single_paragraph_mode (CFPlus::Layout self, int spm) 1557set_single_paragraph_mode (DC::Layout self, int spm)
1263 CODE: 1558 CODE:
1264 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1559 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1265 1560
1266void 1561void
1267size (CFPlus::Layout self) 1562size (DC::Layout self)
1268 PPCODE: 1563 PPCODE:
1269{ 1564{
1270 int w, h; 1565 int w, h;
1271 1566
1272 layout_get_pixel_size (self, &w, &h); 1567 layout_get_pixel_size (self, &w, &h);
… …
1275 PUSHs (sv_2mortal (newSViv (w))); 1570 PUSHs (sv_2mortal (newSViv (w)));
1276 PUSHs (sv_2mortal (newSViv (h))); 1571 PUSHs (sv_2mortal (newSViv (h)));
1277} 1572}
1278 1573
1279int 1574int
1280descent (CFPlus::Layout self) 1575descent (DC::Layout self)
1281 CODE: 1576 CODE:
1282{ 1577{
1283 PangoRectangle rect; 1578 PangoRectangle rect;
1284 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1579 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1285 pango_layout_line_get_pixel_extents (line, 0, &rect); 1580 pango_layout_line_get_pixel_extents (line, 0, &rect);
1286 RETVAL = PANGO_DESCENT (rect); 1581 RETVAL = PANGO_DESCENT (rect);
1287} 1582}
1288 OUTPUT: 1583 OUTPUT:
1289 RETVAL 1584 RETVAL
1290 1585
1291int 1586int
1292xy_to_index (CFPlus::Layout self, int x, int y) 1587xy_to_index (DC::Layout self, int x, int y)
1293 CODE: 1588 CODE:
1294{ 1589{
1295 int index, trailing; 1590 int index, trailing;
1296 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1591 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1297 RETVAL = index + trailing; 1592 RETVAL = index + trailing;
1298} 1593}
1299 OUTPUT: 1594 OUTPUT:
1300 RETVAL 1595 RETVAL
1301 1596
1302void 1597void
1303cursor_pos (CFPlus::Layout self, int index) 1598cursor_pos (DC::Layout self, int index)
1304 PPCODE: 1599 PPCODE:
1305{ 1600{
1306 PangoRectangle strong_pos; 1601 PangoRectangle pos;
1307 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1602 pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1308 1603
1309 EXTEND (SP, 3); 1604 EXTEND (SP, 3);
1310 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1605 PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1311 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1606 PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1312 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1607 PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1313} 1608}
1314 1609
1315void 1610void
1316index_to_line_x (CFPlus::Layout self, int index, int trailing = 0) 1611index_to_line_x (DC::Layout self, int index, int trailing = 0)
1317 PPCODE: 1612 PPCODE:
1318{ 1613{
1319 int line, x; 1614 int line, x;
1320 1615
1321 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x); 1616 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1617#if !PANGO_VERSION_CHECK (1, 17, 3)
1322 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1618 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1323 1619 --line;
1620#endif
1324 EXTEND (SP, 2); 1621 EXTEND (SP, 2);
1325 PUSHs (sv_2mortal (newSViv (line - 1))); 1622 PUSHs (sv_2mortal (newSViv (line)));
1326 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE))); 1623 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1327} 1624}
1328 1625
1329void 1626void
1330line_x_to_index (CFPlus::Layout self, int line, int x) 1627line_x_to_index (DC::Layout self, int line, int x)
1331 PPCODE: 1628 PPCODE:
1332{ 1629{
1333 PangoLayoutLine *lp; 1630 PangoLayoutLine *lp;
1334 int index, trailing; 1631 int index, trailing;
1335 1632
1336 if (line < 0) 1633 if (line < 0)
1337 XSRETURN_EMPTY; 1634 XSRETURN_EMPTY;
1338 1635
1339 if (!(lp = pango_layout_get_line (self->pl, line))) 1636 if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1340 XSRETURN_EMPTY; /* do better */ 1637 XSRETURN_EMPTY; /* do better */
1341 1638
1342 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing); 1639 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1343 1640
1344 EXTEND (SP, 2); 1641 EXTEND (SP, 2);
… …
1350 PUSHs (sv_2mortal (newSViv (trailing))); 1647 PUSHs (sv_2mortal (newSViv (trailing)));
1351 } 1648 }
1352} 1649}
1353 1650
1354void 1651void
1355render (CFPlus::Layout self, float x, float y, int flags = 0) 1652render (DC::Layout self, float x, float y, int flags = 0)
1356 CODE: 1653 CODE:
1357 rc_clear (self->rc); 1654 self->rc.clear ();
1358 pango_opengl_render_layout_subpixel ( 1655 pango_opengl_render_layout_subpixel (
1359 self->pl, 1656 self->pl,
1360 self->rc, 1657 &self->rc,
1361 x * PANGO_SCALE, y * PANGO_SCALE, 1658 x * PANGO_SCALE, y * PANGO_SCALE,
1362 self->r, self->g, self->b, self->a, 1659 self->r, self->g, self->b, self->a,
1363 flags 1660 flags
1364 ); 1661 );
1365 // we assume that context_change actually clears/frees stuff 1662 // we assume that context_change actually clears/frees stuff
1366 // and does not do any recomputation... 1663 // and does not do any recomputation...
1367 pango_layout_context_changed (self->pl); 1664 pango_layout_context_changed (self->pl);
1368 1665
1369void 1666void
1370draw (CFPlus::Layout self) 1667draw (DC::Layout self)
1371 CODE: 1668 CODE:
1372{ 1669{
1373 glEnable (GL_TEXTURE_2D); 1670 glEnable (GL_TEXTURE_2D);
1374 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 1671 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1375 glEnable (GL_BLEND); 1672 glEnable (GL_BLEND);
1376 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1673 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1377 GL_ONE , GL_ONE_MINUS_SRC_ALPHA); 1674 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1378 glEnable (GL_ALPHA_TEST); 1675 glEnable (GL_ALPHA_TEST);
1379 glAlphaFunc (GL_GREATER, 7.f / 255.f); 1676 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1380 1677
1381 rc_draw (self->rc); 1678 self->rc.draw ();
1382 1679
1383 glDisable (GL_ALPHA_TEST); 1680 glDisable (GL_ALPHA_TEST);
1384 glDisable (GL_BLEND); 1681 glDisable (GL_BLEND);
1385 glDisable (GL_TEXTURE_2D); 1682 glDisable (GL_TEXTURE_2D);
1386} 1683}
1387 1684
1388MODULE = CFPlus PACKAGE = CFPlus::Texture 1685MODULE = Deliantra::Client PACKAGE = DC::Texture
1389 1686
1390PROTOTYPES: ENABLE 1687PROTOTYPES: ENABLE
1391 1688
1392void 1689void
1393pad (SV *data_, int ow, int oh, int nw, int nh) 1690pad (SV *data_, int ow, int oh, int nw, int nh)
… …
1461 glDisable (GL_ALPHA_TEST); 1758 glDisable (GL_ALPHA_TEST);
1462 glDisable (GL_BLEND); 1759 glDisable (GL_BLEND);
1463 } 1760 }
1464} 1761}
1465 1762
1763void
1764draw_fow_texture (float intensity, int hidden_tex, int name1, uint8_t *data1, float s, float t, int w, int h, float blend = 0.f, int dx = 0, int dy = 0, int name2 = 0, uint8_t *data2 = data1)
1765 PROTOTYPE: @
1766 CODE:
1767{
1768 glEnable (GL_BLEND);
1769 glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1770 glEnable (GL_TEXTURE_2D);
1771 glBindTexture (GL_TEXTURE_2D, name1);
1772
1773 glColor3f (intensity, intensity, intensity);
1774 glPushMatrix ();
1775 glScalef (1./3, 1./3, 1.);
1776
1777 if (blend > 0.f)
1778 {
1779 float dx3 = dx * -3.f / w;
1780 float dy3 = dy * -3.f / h;
1781 GLfloat env_color[4] = { 0., 0., 0., blend };
1782
1783 /* interpolate the two shadow textures */
1784 /* stage 0 == rgb(glcolor) + alpha(t0) */
1785 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1786
1787 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1788 gl.ActiveTexture (GL_TEXTURE1);
1789 glEnable (GL_TEXTURE_2D);
1790 glBindTexture (GL_TEXTURE_2D, name2);
1791 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1792
1793 /* rgb == rgb(glcolor) */
1794 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1795 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
1796 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1797
1798 /* alpha = interpolate t0, t1 by env_alpha */
1799 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1800
1801 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1802 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1803 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1804
1805 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1806 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1807
1808 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1809 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1810
1811 glBegin (GL_QUADS);
1812 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1813 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1814 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1815 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1816 glEnd ();
1817
1818 glDisable (GL_TEXTURE_2D);
1819 gl.ActiveTexture (GL_TEXTURE0);
1820 }
1821 else
1822 {
1823 /* simple blending of one texture, also opengl <1.3 path */
1824 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1825
1826 glBegin (GL_QUADS);
1827 glTexCoord2f (0, 0); glVertex2f (0, 0);
1828 glTexCoord2f (0, t); glVertex2f (0, h);
1829 glTexCoord2f (s, t); glVertex2f (w, h);
1830 glTexCoord2f (s, 0); glVertex2f (w, 0);
1831 glEnd ();
1832 }
1833
1834 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1835 {
1836 int x, y;
1837 int dx3 = dx * 3;
1838 int dy3 = dy * 3;
1839
1840 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1841 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1842 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1843 glTranslatef (-1., -1., 0);
1844 glBegin (GL_QUADS);
1845
1846 for (y = 1; y < h; y += 3)
1847 {
1848 int y1 = y - dy3;
1849 int y1valid = y1 >= 0 && y1 < h;
1850
1851 for (x = 1; x < w; x += 3)
1852 {
1853 int x1 = x - dx3;
1854 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1855 uint8_t h2;
1856
1857 if (y1valid && x1 >= 0 && x1 < w)
1858 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1859 else
1860 h2 = 1; /* out of range == invisible */
1861
1862 if (h1 || h2)
1863 {
1864 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1865 glColor4f (1., 1., 1., alpha);
1866
1867 glTexCoord2f (0, 0.); glVertex2i (x , y );
1868 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1869 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1870 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1871 }
1872 }
1873 }
1874 }
1875
1876 glEnd ();
1877
1878 glPopMatrix ();
1879
1880 glDisable (GL_TEXTURE_2D);
1881 glDisable (GL_BLEND);
1882}
1883
1466IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1884IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1467 CODE: 1885 CODE:
1468{ 1886{
1469 GLint width; 1887 GLint width;
1470 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0); 1888 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
… …
1472 RETVAL = width > 0; 1890 RETVAL = width > 0;
1473} 1891}
1474 OUTPUT: 1892 OUTPUT:
1475 RETVAL 1893 RETVAL
1476 1894
1477MODULE = CFPlus PACKAGE = CFPlus::Map 1895MODULE = Deliantra::Client PACKAGE = DC::Map
1478 1896
1479PROTOTYPES: DISABLE 1897PROTOTYPES: DISABLE
1480 1898
1481CFPlus::Map 1899DC::Map
1482new (SV *class) 1900new (SV *klass)
1483 CODE: 1901 CODE:
1484 New (0, RETVAL, 1, struct map); 1902 New (0, RETVAL, 1, mapgrid);
1485 RETVAL->x = 0; 1903 RETVAL->x = 0;
1486 RETVAL->y = 0; 1904 RETVAL->y = 0;
1487 RETVAL->w = 0; 1905 RETVAL->w = 0;
1488 RETVAL->h = 0; 1906 RETVAL->h = 0;
1489 RETVAL->ox = 0; 1907 RETVAL->ox = 0;
… …
1494 RETVAL->row = 0; 1912 RETVAL->row = 0;
1495 OUTPUT: 1913 OUTPUT:
1496 RETVAL 1914 RETVAL
1497 1915
1498void 1916void
1499DESTROY (CFPlus::Map self) 1917DESTROY (DC::Map self)
1500 CODE: 1918 CODE:
1501{ 1919{
1502 map_clear (self); 1920 map_clear (self);
1503 Safefree (self->face2tile); 1921 Safefree (self->face2tile);
1504 Safefree (self->tex); 1922 Safefree (self->tex);
1505 Safefree (self); 1923 Safefree (self);
1506} 1924}
1507 1925
1508void 1926void
1509resize (CFPlus::Map self, int map_width, int map_height) 1927resize (DC::Map self, int map_width, int map_height)
1510 CODE: 1928 CODE:
1511 self->w = map_width; 1929 self->w = map_width;
1512 self->h = map_height; 1930 self->h = map_height;
1513 1931
1514void 1932void
1515clear (CFPlus::Map self) 1933clear (DC::Map self)
1516 CODE: 1934 CODE:
1517 map_clear (self); 1935 map_clear (self);
1518 1936
1519void 1937void
1520set_tileid (CFPlus::Map self, int face, int tile) 1938set_tileid (DC::Map self, int face, int tile)
1521 CODE: 1939 CODE:
1522{ 1940{
1523 need_facenum (self, face); self->face2tile [face] = tile; 1941 need_facenum (self, face); self->face2tile [face] = tile;
1524 need_texid (self, tile); 1942 need_texid (self, tile);
1525} 1943}
1526 1944
1527void 1945void
1528set_smooth (CFPlus::Map self, int face, int smooth, int level) 1946set_smooth (DC::Map self, int face, int smooth, int level)
1529 CODE: 1947 CODE:
1530{ 1948{
1531 tileid texid; 1949 tileid texid;
1532 maptex *tex; 1950 maptex *tex;
1533 1951
1534 if (face < 0 || face >= self->faces) 1952 if (face < 0 || face >= self->faces)
1535 return; 1953 return;
1536 1954
1537 if (smooth < 0 || smooth >= self->faces) 1955 if (smooth < 0 || smooth >= self->faces)
1538 return; 1956 return;
1539 1957
1540 texid = self->face2tile [face]; 1958 texid = self->face2tile [face];
1541 1959
1542 if (!texid) 1960 if (!texid)
1543 return; 1961 return;
1544 1962
1545 tex = self->tex + texid; 1963 tex = self->tex + texid;
1546 tex->smoothtile = self->face2tile [smooth]; 1964 tex->smoothtile = self->face2tile [smooth];
1547 tex->smoothlevel = level; 1965 tex->smoothlevel = level;
1548} 1966}
1549 1967
1550void 1968void
1551set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1969set_texture (DC::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1552 CODE: 1970 CODE:
1553{ 1971{
1554 need_texid (self, texid); 1972 need_texid (self, texid);
1555 1973
1556 { 1974 {
… …
1575 // use uglier nearest interpolation because linear suffers 1993 // use uglier nearest interpolation because linear suffers
1576 // from transparent color bleeding and ugly wrapping effects. 1994 // from transparent color bleeding and ugly wrapping effects.
1577 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1995 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1578} 1996}
1579 1997
1998void
1999expire_textures (DC::Map self, int texid, int count)
2000 PPCODE:
2001 for (; texid < self->texs && count; ++texid, --count)
2002 {
2003 maptex *tex = self->tex + texid;
2004
2005 if (tex->name)
2006 {
2007 if (tex->unused)
2008 {
2009 tex->name = 0;
2010 tex->unused = 0;
2011 XPUSHs (sv_2mortal (newSViv (texid)));
2012 }
2013 else
2014 tex->unused = 1;
2015 }
2016 }
2017
1580int 2018int
1581ox (CFPlus::Map self) 2019ox (DC::Map self)
1582 ALIAS: 2020 ALIAS:
1583 oy = 1 2021 oy = 1
1584 x = 2 2022 x = 2
1585 y = 3 2023 y = 3
1586 w = 4 2024 w = 4
… …
1597 } 2035 }
1598 OUTPUT: 2036 OUTPUT:
1599 RETVAL 2037 RETVAL
1600 2038
1601void 2039void
1602scroll (CFPlus::Map self, int dx, int dy) 2040scroll (DC::Map self, int dx, int dy)
1603 CODE: 2041 CODE:
1604{ 2042{
1605 if (dx > 0) 2043 if (dx > 0)
1606 map_blank (self, self->x, self->y, dx, self->h); 2044 map_blank (self, self->x, self->y, dx, self->h);
1607 else if (dx < 0) 2045 else if (dx < 0)
… …
1615 self->ox += dx; self->x += dx; 2053 self->ox += dx; self->x += dx;
1616 self->oy += dy; self->y += dy; 2054 self->oy += dy; self->y += dy;
1617 2055
1618 while (self->y < 0) 2056 while (self->y < 0)
1619 { 2057 {
1620 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 2058 prepend (self->row, self->rows, MAP_EXTEND_Y);
1621 2059
1622 self->rows += MAP_EXTEND_Y; 2060 self->rows += MAP_EXTEND_Y;
1623 self->y += MAP_EXTEND_Y; 2061 self->y += MAP_EXTEND_Y;
1624 } 2062 }
1625} 2063}
1626 2064
1627SV * 2065SV *
1628map1a_update (CFPlus::Map self, SV *data_, int extmap) 2066map1a_update (DC::Map self, SV *data_)
1629 CODE: 2067 CODE:
1630{ 2068{
1631 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2069 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1632 uint8_t *data_end = (uint8_t *)SvEND (data_); 2070 uint8_t *data_end = (uint8_t *)SvEND (data_);
1633 mapcell *cell; 2071 mapcell *cell;
… …
1654 2092
1655 //TODO: don't trust server data to be in-range(!) 2093 //TODO: don't trust server data to be in-range(!)
1656 2094
1657 if (flags & 8) 2095 if (flags & 8)
1658 { 2096 {
2097 uint8_t ext, cmd;
2098
1659 if (extmap) 2099 do
1660 { 2100 {
1661 uint8_t ext, cmd; 2101 ext = *data++;
2102 cmd = ext & 0x7f;
1662 2103
1663 do 2104 if (cmd < 4)
2105 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
2106 else if (cmd == 5) // health
1664 { 2107 {
1665 ext = *data++;
1666 cmd = ext & 0x3f;
1667
1668 if (cmd < 4)
1669 cell->darkness = 255 - ext * 64 + 1;
1670 else if (cmd == 5) // health
1671 {
1672 cell->stat_width = 1; 2108 cell->stat_width = 1;
1673 cell->stat_hp = *data++; 2109 cell->stat_hp = *data++;
1674 }
1675 else if (cmd == 6) // monster width
1676 cell->stat_width = *data++ + 1;
1677 else if (cmd == 0x47)
1678 {
1679 if (*data == 4)
1680 ; // decode player count
1681
1682 data += *data + 1;
1683 }
1684 else if (cmd == 8) // cell flags
1685 cell->flags = *data++;
1686 else if (ext & 0x40) // unknown, multibyte => skip
1687 data += *data + 1;
1688 else
1689 data++;
1690 } 2110 }
1691 while (ext & 0x80); 2111 else if (cmd == 6) // monster width
2112 cell->stat_width = *data++ + 1;
2113 else if (cmd == 0x47)
2114 {
2115 if (*data == 1) cell->player = data [1];
2116 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2117 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2118 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
2119
2120 data += *data + 1;
2121 }
2122 else if (cmd == 8) // cell flags
2123 cell->flags = *data++;
2124 else if (ext & 0x40) // unknown, multibyte => skip
2125 data += *data + 1;
2126 else
2127 data++;
1692 } 2128 }
1693 else 2129 while (ext & 0x80);
1694 cell->darkness = *data++ + 1;
1695 } 2130 }
1696 2131
1697 for (z = 0; z <= 2; ++z) 2132 for (z = 0; z <= 2; ++z)
1698 if (flags & (4 >> z)) 2133 if (flags & (4 >> z))
1699 { 2134 {
… …
1702 cell->tile [z] = self->face2tile [face]; 2137 cell->tile [z] = self->face2tile [face];
1703 2138
1704 if (cell->tile [z]) 2139 if (cell->tile [z])
1705 { 2140 {
1706 maptex *tex = self->tex + cell->tile [z]; 2141 maptex *tex = self->tex + cell->tile [z];
2142 tex->unused = 0;
1707 if (!tex->name) 2143 if (!tex->name)
1708 av_push (missing, newSViv (cell->tile [z])); 2144 av_push (missing, newSViv (cell->tile [z]));
1709 2145
1710 if (tex->smoothtile) 2146 if (tex->smoothtile)
1711 { 2147 {
1712 maptex *smooth = self->tex + tex->smoothtile; 2148 maptex *smooth = self->tex + tex->smoothtile;
2149 smooth->unused = 0;
1713 if (!smooth->name) 2150 if (!smooth->name)
1714 av_push (missing, newSViv (tex->smoothtile)); 2151 av_push (missing, newSViv (tex->smoothtile));
1715 } 2152 }
1716 } 2153 }
1717 } 2154 }
1718 } 2155 }
1719 else 2156 else
1720 cell->darkness = 0; 2157 CELL_CLEAR (cell);
1721 } 2158 }
1722} 2159}
1723 OUTPUT: 2160 OUTPUT:
1724 RETVAL 2161 RETVAL
1725 2162
1726SV * 2163SV *
1727mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 2164mapmap (DC::Map self, int x0, int y0, int w, int h)
1728 CODE: 2165 CODE:
1729{ 2166{
1730 int x1, x; 2167 int x1, x;
1731 int y1, y; 2168 int y1, y;
1732 int z; 2169 int z;
… …
1745 ? self->row + y 2182 ? self->row + y
1746 : 0; 2183 : 0;
1747 2184
1748 for (x = x0; x < x1; x++) 2185 for (x = x0; x < x1; x++)
1749 { 2186 {
1750 int r = 32, g = 32, b = 32, a = 192; 2187 unsigned int r = 32, g = 32, b = 32, a = 192;
1751 2188
1752 if (row && row->c0 <= x && x < row->c1) 2189 if (row && row->c0 <= x && x < row->c1)
1753 { 2190 {
1754 mapcell *cell = row->col + (x - row->c0); 2191 mapcell *cell = row->col + (x - row->c0);
1755 2192
… …
1757 { 2194 {
1758 maptex tex = self->tex [cell->tile [z]]; 2195 maptex tex = self->tex [cell->tile [z]];
1759 int a0 = 255 - tex.a; 2196 int a0 = 255 - tex.a;
1760 int a1 = tex.a; 2197 int a1 = tex.a;
1761 2198
1762 r = (r * a0 + tex.r * a1) / 255; 2199 r = div255 (r * a0 + tex.r * a1);
1763 g = (g * a0 + tex.g * a1) / 255; 2200 g = div255 (g * a0 + tex.g * a1);
1764 b = (b * a0 + tex.b * a1) / 255; 2201 b = div255 (b * a0 + tex.b * a1);
1765 a = (a * a0 + tex.a * a1) / 255; 2202 a = div255 (a * a0 + tex.a * a1);
1766 } 2203 }
1767 } 2204 }
1768 2205
1769 *map++ = (r ) 2206 *map++ = (r )
1770 | (g << 8) 2207 | (g << 8)
1771 | (b << 16) 2208 | (b << 16)
1772 | (a << 24); 2209 | (a << 24);
1773 } 2210 }
1774 } 2211 }
1775 2212
1776 RETVAL = map_sv; 2213 RETVAL = map_sv;
1777} 2214}
1778 OUTPUT: 2215 OUTPUT:
1779 RETVAL 2216 RETVAL
1780 2217
1781void 2218void
1782draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T) 2219draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1783 CODE: 2220 CODE:
1784{ 2221{
1785 int x, y, z; 2222 int x, y, z;
1786 2223
1787 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1788 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1789 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2224 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
1790 smooth_key skey; 2225 int pl_x, pl_y;
1791 2226 maptex pl_tex;
1792 rc_t *rc = rc_alloc (); 2227 rc_t rc;
2228 rc_t rc_ov;
1793 rc_key_t key; 2229 rc_key_t key;
1794 rc_array_t *arr; 2230 rc_t::array_t *arr;
1795 2231
2232 pl_tex.name = 0;
2233
1796 // thats current max. sorry. 2234 // that's current max. sorry.
1797 if (sw > 255) sw = 255; 2235 if (sw > 255) sw = 255;
1798 if (sh > 255) sh = 255; 2236 if (sh > 255) sh = 255;
1799
1800 // clear key, in case of extra padding
1801 memset (&skey, 0, sizeof (skey));
1802 2237
1803 memset (&key, 0, sizeof (key)); 2238 memset (&key, 0, sizeof (key));
1804 key.r = 255; 2239 key.r = 255;
1805 key.g = 255; 2240 key.g = 255;
1806 key.b = 255; 2241 key.b = 255;
1807 key.a = 255; 2242 key.a = 255;
1808 key.mode = GL_QUADS; 2243 key.mode = GL_QUADS;
1809 key.format = GL_T2F_V3F; 2244 key.format = GL_T2F_V3F;
1810 key.texname = -1;
1811 2245
1812 mx += self->x; 2246 mx += self->x;
1813 my += self->y; 2247 my += self->y;
1814 2248
1815 // first pass: determine smooth_max 2249 // first pass: determine smooth_max
1816 // rather ugly, if you ask me 2250 // rather ugly, if you ask me
1817 // could also be stored inside mapcell and updated on change 2251 // could also be stored inside mapcell and updated on change
1818 memset (smooth_max, 0, sizeof (smooth_max)); 2252 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1819 2253
1820 for (y = 0; y < sh; y++) 2254 for (y = 0; y < sh; y++)
1821 if (0 <= y + my && y + my < self->rows) 2255 if (0 <= y + my && y + my < self->rows)
1822 { 2256 {
1823 maprow *row = self->row + (y + my); 2257 maprow *row = self->row + (y + my);
… …
1838 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2272 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1839 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2273 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1840 2274
1841 for (z = 0; z <= 2; z++) 2275 for (z = 0; z <= 2; z++)
1842 { 2276 {
1843 memset (smooth_level, 0, sizeof (smooth_level)); 2277 std::bitset<256> smooth_level; // one bit for every possible smooth level
2278 smooth_key skey;
2279 smooth_hash smooth;
2280 key.texname = -1;
1844 2281
1845 for (y = 0; y < sh; y++) 2282 for (y = 0; y < sh; y++)
1846 if (0 <= y + my && y + my < self->rows) 2283 if (0 <= y + my && y + my < self->rows)
1847 { 2284 {
1848 maprow *row = self->row + (y + my); 2285 maprow *row = self->row + (y + my);
… …
1858 maptex tex = self->tex [tile]; 2295 maptex tex = self->tex [tile];
1859 int px, py; 2296 int px, py;
1860 2297
1861 if (key.texname != tex.name) 2298 if (key.texname != tex.name)
1862 { 2299 {
2300 self->tex [tile].unused = 0;
2301
1863 if (!tex.name) 2302 if (!tex.name)
1864 tex = self->tex [2]; /* missing, replace by noface */ 2303 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1865 2304
1866 key.texname = tex.name; 2305 key.texname = tex.name;
1867 arr = rc_array (rc, &key); 2306 arr = &rc.array (key);
1868 } 2307 }
1869 2308
1870 px = (x + 1) * T - tex.w; 2309 px = (x + 1) * Th - tex.w;
1871 py = (y + 1) * T - tex.h; 2310 py = (y + 1) * Tw - tex.h;
1872 2311
1873 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2312 if (expect_false (cell->player == player) && expect_false (z == 2))
1874 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1875 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1876 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1877
1878 if (cell->flags && z == 2)
1879 { 2313 {
1880 // overlays such as the speech bubble, probably more to come 2314 pl_x = px;
1881 if (cell->flags & 1) 2315 pl_y = py;
2316 pl_tex = tex;
1882 { 2317 continue;
1883 maptex tex = self->tex [1];
1884 int px = x * T + T * 2 / 32;
1885 int py = y * T - T * 6 / 32;
1886
1887 if (tex.name)
1888 {
1889 if (key.texname != tex.name)
1890 {
1891 key.texname = tex.name;
1892 arr = rc_array (rc, &key);
1893 }
1894
1895 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1896 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1897 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1898 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1899 }
1900 }
1901 } 2318 }
2319
2320 arr->t2f_v3f (0 , 0 , px , py , 0);
2321 arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2322 arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2323 arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
1902 2324
1903 // update smooth hash 2325 // update smooth hash
1904 if (tex.smoothtile) 2326 if (tex.smoothtile)
1905 { 2327 {
1906 skey.tile = tex.smoothtile; 2328 skey.tile = tex.smoothtile;
1907 skey.level = tex.smoothlevel; 2329 skey.level = tex.smoothlevel;
1908 2330
1909 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2331 smooth_level[tex.smoothlevel] = 1;
1910 2332
1911 // add bits to current tile and all neighbours. skey.x|y is 2333 // add bits to current tile and all neighbours. skey.x|y is
1912 // shifted +1|+1 so we always stay positive. 2334 // shifted +1|+1 so we always stay positive.
1913 2335
1914 // bits is ___n cccc CCCC bbbb 2336 // bits is ___n cccc CCCC bbbb
… …
1922 2344
1923 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2345 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1924 // ·· ·· ·┏ ┓· 2346 // ·· ·· ·┏ ┓·
1925 2347
1926 // full tile 2348 // full tile
1927 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 2349 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
1928 2350
1929 // borders 2351 // borders
1930 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091); 2352 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
1931 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032); 2353 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
1932 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 2354 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
1933 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 2355 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
1934 2356
1935 // corners 2357 // corners
1936 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2358 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
1937 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2359 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
1938 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2360 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
1939 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2361 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
2362 }
2363 }
2364
2365 if (expect_false (z == 2) && expect_false (cell->flags))
2366 {
2367 // overlays such as the speech bubble, probably more to come
2368 if (cell->flags & 1)
2369 {
2370 rc_key_t key_ov = key;
2371 maptex tex = self->tex[TEXID_SPEECH];
2372 int px = x * Tw + Tw * 2 / 32;
2373 int py = y * Th - Th * 6 / 32;
2374
2375 key_ov.texname = tex.name;
2376 rc_t::array_t &arr = rc_ov.array (key_ov);
2377
2378 arr.t2f_v3f (0 , 0 , px , py , 0);
2379 arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
2380 arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
2381 arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
1940 } 2382 }
1941 } 2383 }
1942 } 2384 }
1943 } 2385 }
1944 2386
1945 rc_draw (rc); 2387 rc.draw ();
1946 rc_clear (rc); 2388 rc.clear ();
1947 2389
1948 // go through all smoothlevels, lowest to highest, then draw. 2390 // go through all smoothlevels, lowest to highest, then draw.
1949 // this is basically counting sort 2391 // this is basically counting sort
1950 { 2392 {
1951 int w, b; 2393 int w, b;
1952 2394
1953 glEnable (GL_TEXTURE_2D); 2395 glEnable (GL_TEXTURE_2D);
1954 glBegin (GL_QUADS); 2396 glBegin (GL_QUADS);
1955 for (w = 0; w < 256 / 32; ++w) 2397 for (int level = 0; level < smooth_level.size (); ++level)
2398 if (smooth_level[level])
2399 for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
1956 { 2400 {
1957 uint32_t smask = smooth_level [w]; 2401 smooth_key &skey = it->first;
1958 if (smask) 2402 IV bits = it->second;
1959 for (b = 0; b < 32; ++b) 2403
1960 if (smask & (((uint32_t)1) << b)) 2404 if (!(bits & 0x1000)
2405 && skey.level == level
2406 && level > smooth_max [skey.x][skey.y])
1961 { 2407 {
1962 int level = (w << 5) | b; 2408 maptex tex = self->tex [skey.tile];
2409 int px = (((int)skey.x) - 1) * Tw;
2410 int py = (((int)skey.y) - 1) * Th;
2411 int border = bits & 15;
2412 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2413 float dx = tex.s * .0625f; // 16 images/row
2414 float dy = tex.t * .5f ; // 2 images/column
2415
1963 HE *he; 2416 if (tex.name)
1964
1965 hv_iterinit (smooth);
1966 while ((he = hv_iternext (smooth)))
1967 { 2417 {
1968 smooth_key *skey = (smooth_key *)HeKEY (he); 2418 // this time avoiding texture state changes
1969 IV bits = SvIVX (HeVAL (he)); 2419 // save gobs of state changes.
1970 2420 if (key.texname != tex.name)
1971 if (!(bits & 0x1000)
1972 && skey->level == level
1973 && level > smooth_max [skey->x][skey->y])
1974 { 2421 {
1975 maptex tex = self->tex [skey->tile]; 2422 self->tex [skey.tile].unused = 0;
1976 int px = (((int)skey->x) - 1) * T;
1977 int py = (((int)skey->y) - 1) * T;
1978 int border = bits & 15;
1979 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1980 float dx = tex.s * .0625f; // 16 images/row
1981 float dy = tex.t * .5f ; // 2 images/column
1982 2423
1983 if (tex.name)
1984 {
1985 // this time avoiding texture state changes
1986 // save gobs of state changes.
1987 if (key.texname != tex.name)
1988 {
1989 glEnd (); 2424 glEnd ();
1990 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2425 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1991 glBegin (GL_QUADS); 2426 glBegin (GL_QUADS);
1992 } 2427 }
1993 2428
1994 if (border) 2429 if (border)
1995 { 2430 {
1996 float ox = border * dx; 2431 float ox = border * dx;
1997 2432
1998 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2433 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1999 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2434 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2000 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2435 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2001 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2436 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2002 } 2437 }
2003 2438
2004 if (corner) 2439 if (corner)
2005 { 2440 {
2006 float ox = corner * dx; 2441 float ox = corner * dx;
2007 2442
2008 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2443 glTexCoord2f (ox , dy ); glVertex2i (px , py );
2009 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2444 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2010 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2445 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2011 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2446 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2012 }
2013 }
2014 } 2447 }
2015 } 2448 }
2016 } 2449 }
2017 } 2450 }
2018 2451
2019 glEnd (); 2452 glEnd ();
2020 glDisable (GL_TEXTURE_2D); 2453 glDisable (GL_TEXTURE_2D);
2021 key.texname = -1; 2454 key.texname = -1;
2022 } 2455 }
2023
2024 hv_clear (smooth);
2025 } 2456 }
2026 2457
2458 if (pl_tex.name)
2459 {
2460 maptex tex = pl_tex;
2461 int px = pl_x + sdx;
2462 int py = pl_y + sdy;
2463
2464 key.texname = tex.name;
2465 rc_t::array_t &arr = rc.array (key);
2466
2467 arr.t2f_v3f (0 , 0 , px , py , 0);
2468 arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2469 arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2470 arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2471
2472 rc.draw ();
2473 }
2474
2475 rc_ov.draw ();
2476 rc_ov.clear ();
2477
2027 glDisable (GL_BLEND); 2478 glDisable (GL_BLEND);
2028 rc_free (rc);
2029 2479
2030 // top layer: overlays such as the health bar 2480 // top layer: overlays such as the health bar
2031 for (y = 0; y < sh; y++) 2481 for (y = 0; y < sh; y++)
2032 if (0 <= y + my && y + my < self->rows) 2482 if (0 <= y + my && y + my < self->rows)
2033 { 2483 {
… …
2036 for (x = 0; x < sw; x++) 2486 for (x = 0; x < sw; x++)
2037 if (row->c0 <= x + mx && x + mx < row->c1) 2487 if (row->c0 <= x + mx && x + mx < row->c1)
2038 { 2488 {
2039 mapcell *cell = row->col + (x + mx - row->c0); 2489 mapcell *cell = row->col + (x + mx - row->c0);
2040 2490
2041 int px = x * T; 2491 int px = x * Tw;
2042 int py = y * T; 2492 int py = y * Th;
2493
2494 if (expect_false (cell->player == player))
2495 {
2496 px += sdx;
2497 py += sdy;
2498 }
2043 2499
2044 if (cell->stat_hp) 2500 if (cell->stat_hp)
2045 { 2501 {
2046 int width = cell->stat_width * T; 2502 int width = cell->stat_width * Tw;
2047 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2503 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2048 2504
2049 glColor3ub (0, 0, 0); 2505 glColor3ub (0, 0, 0);
2050 glRectf (px + 1, py - thick - 2, 2506 glRectf (px + 1, py - thick - 2,
2051 px + width - 1, py); 2507 px + width - 1, py);
2052 2508
… …
2058 } 2514 }
2059 } 2515 }
2060} 2516}
2061 2517
2062void 2518void
2063draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data) 2519draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2064 CODE: 2520 CODE:
2065{ 2521{
2066 static float color[16][3] = { 2522 static float color[16][3] = {
2067 { 0.00F, 0.00F, 0.00F }, 2523 { 0.00f, 0.00f, 0.00f },
2068 { 1.00F, 1.00F, 1.00F }, 2524 { 1.00f, 1.00f, 1.00f },
2069 { 0.00F, 0.00F, 0.55F }, 2525 { 0.00f, 0.00f, 0.55f },
2070 { 1.00F, 0.00F, 0.00F }, 2526 { 1.00f, 0.00f, 0.00f },
2071 2527
2072 { 1.00F, 0.54F, 0.00F }, 2528 { 1.00f, 0.54f, 0.00f },
2073 { 0.11F, 0.56F, 1.00F }, 2529 { 0.11f, 0.56f, 1.00f },
2074 { 0.93F, 0.46F, 0.00F }, 2530 { 0.93f, 0.46f, 0.00f },
2075 { 0.18F, 0.54F, 0.34F }, 2531 { 0.18f, 0.54f, 0.34f },
2076 2532
2077 { 0.56F, 0.73F, 0.56F }, 2533 { 0.56f, 0.73f, 0.56f },
2078 { 0.80F, 0.80F, 0.80F }, 2534 { 0.80f, 0.80f, 0.80f },
2079 { 0.55F, 0.41F, 0.13F }, 2535 { 0.55f, 0.41f, 0.13f },
2080 { 0.99F, 0.77F, 0.26F }, 2536 { 0.99f, 0.77f, 0.26f },
2081 2537
2082 { 0.74F, 0.65F, 0.41F }, 2538 { 0.74f, 0.65f, 0.41f },
2083 2539
2084 { 0.00F, 1.00F, 1.00F }, 2540 { 0.00f, 1.00f, 1.00f },
2085 { 1.00F, 0.00F, 1.00F }, 2541 { 1.00f, 0.00f, 1.00f },
2086 { 1.00F, 1.00F, 0.00F }, 2542 { 1.00f, 1.00f, 0.00f },
2087 }; 2543 };
2088 2544
2089 int x, y; 2545 int x, y;
2090 2546
2091 glEnable (GL_TEXTURE_2D); 2547 glEnable (GL_TEXTURE_2D);
2548 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2549 * but the nvidia driver (185.18.14) mishandles alpha textures
2550 * and takes the colour from god knows where instead of using
2551 * Cp. MODULATE results in the same colour, but slightly different
2552 * alpha, but atcually gives us the correct colour with nvidia.
2553 */
2092 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2554 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2093 glEnable (GL_BLEND); 2555 glEnable (GL_BLEND);
2094 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2556 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2095 glBegin (GL_QUADS); 2557 glBegin (GL_QUADS);
2096 2558
2097 for (y = 0; y < h; y++) 2559 for (y = 0; y < h; y++)
… …
2101 2563
2102 if (m) 2564 if (m)
2103 { 2565 {
2104 float *c = color [m & 15]; 2566 float *c = color [m & 15];
2105 2567
2106 float tx1 = m & 0x40 ? 0.5 : 0.; 2568 float tx1 = m & 0x40 ? 0.5f : 0.f;
2107 float tx2 = tx1 + 0.5; 2569 float tx2 = tx1 + 0.5f;
2108 2570
2109 glColor4f (c[0], c[1], c[2], 0.75); 2571 glColor4f (c[0], c[1], c[2], 1);
2110 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2572 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2111 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2573 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2112 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2574 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2113 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2575 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2114 } 2576 }
… …
2118 glDisable (GL_BLEND); 2580 glDisable (GL_BLEND);
2119 glDisable (GL_TEXTURE_2D); 2581 glDisable (GL_TEXTURE_2D);
2120} 2582}
2121 2583
2122void 2584void
2123fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh) 2585fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2124 PPCODE: 2586 PPCODE:
2125{ 2587{
2126 int x, y; 2588 int x, y;
2127 int sw1 = sw + 2; 2589 int sw1 = sw + 2;
2128 int sh1 = sh + 2; 2590 int sh1 = sh + 2;
2129 int sh3 = sh * 3; 2591 int sh3 = sh * 3;
2130 int sw34 = (sw * 3 + 3) & ~3; 2592 int sw3 = sw * 3;
2593 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2594 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2131 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2595 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2132 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2596 memset (darkness1, 0, sw1*sh1);
2133 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2134 2597
2135 SvPOK_only (darkness3_sv); 2598 SvPOK_only (darkness3_sv);
2136 SvCUR_set (darkness3_sv, sw34 * sh3); 2599 SvCUR_set (darkness3_sv, sw3 * sh3);
2137 2600
2138 mx += self->x - 1; 2601 mx += self->x - 1;
2139 my += self->y - 1; 2602 my += self->y - 1;
2140
2141 memset (darkness1, 255, sw1 * sh1);
2142 2603
2143 for (y = 0; y < sh1; y++) 2604 for (y = 0; y < sh1; y++)
2144 if (0 <= y + my && y + my < self->rows) 2605 if (0 <= y + my && y + my < self->rows)
2145 { 2606 {
2146 maprow *row = self->row + (y + my); 2607 maprow *row = self->row + (y + my);
… …
2149 if (row->c0 <= x + mx && x + mx < row->c1) 2610 if (row->c0 <= x + mx && x + mx < row->c1)
2150 { 2611 {
2151 mapcell *cell = row->col + (x + mx - row->c0); 2612 mapcell *cell = row->col + (x + mx - row->c0);
2152 2613
2153 darkness1 [y * sw1 + x] = cell->darkness 2614 darkness1 [y * sw1 + x] = cell->darkness
2154 ? 255 - (cell->darkness - 1) 2615 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2155 : 255 - FOW_DARKNESS; 2616 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2156 } 2617 }
2157 } 2618 }
2158 2619
2159 for (y = 0; y < sh; ++y) 2620 for (y = 0; y < sh; ++y)
2160 for (x = 0; x < sw; ++x) 2621 for (x = 0; x < sw; ++x)
… …
2179 2640
2180 uint8_t r13 = (d13 + d23 + d12) / 3; 2641 uint8_t r13 = (d13 + d23 + d12) / 3;
2181 uint8_t r23 = d23; 2642 uint8_t r23 = d23;
2182 uint8_t r33 = (d23 + d33 + d32) / 3; 2643 uint8_t r33 = (d23 + d33 + d32) / 3;
2183 2644
2184 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2645 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2185 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2646 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2186 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2647 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2187 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2648 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2188 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22); 2649 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2189 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2650 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2190 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2651 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2191 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2652 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2192 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2653 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2193 } 2654 }
2194 2655
2195 free (darkness1); 2656 free (darkness1);
2196 2657
2197 EXTEND (SP, 3); 2658 EXTEND (SP, 3);
2198 PUSHs (sv_2mortal (newSViv (sw34))); 2659 PUSHs (sv_2mortal (newSViv (sw3)));
2199 PUSHs (sv_2mortal (newSViv (sh3))); 2660 PUSHs (sv_2mortal (newSViv (sh3)));
2200 PUSHs (darkness3_sv); 2661 PUSHs (darkness3_sv);
2201} 2662}
2202 2663
2203SV * 2664SV *
2204get_rect (CFPlus::Map self, int x0, int y0, int w, int h) 2665get_rect (DC::Map self, int x0, int y0, int w, int h)
2205 CODE: 2666 CODE:
2206{ 2667{
2207 int x, y, x1, y1; 2668 int x, y, x1, y1;
2208 SV *data_sv = newSV (w * h * 7 + 5); 2669 SV *data_sv = newSV (w * h * 7 + 5);
2209 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2670 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
2266 else 2727 else
2267 *data++ = 0; 2728 *data++ = 0;
2268 } 2729 }
2269 } 2730 }
2270 2731
2732 /* if size is w*h + 5 then no data has been found */
2733 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2734 {
2271 SvPOK_only (data_sv); 2735 SvPOK_only (data_sv);
2272 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2736 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2737 }
2738
2273 RETVAL = data_sv; 2739 RETVAL = data_sv;
2274} 2740}
2275 OUTPUT: 2741 OUTPUT:
2276 RETVAL 2742 RETVAL
2277 2743
2278void 2744void
2279set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2745set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2280 PPCODE: 2746 PPCODE:
2281{ 2747{
2282 int x, y, z; 2748 int x, y, z;
2283 int w, h; 2749 int w, h;
2284 int x1, y1; 2750 int x1, y1;
2751 STRLEN len;
2752 uint8_t *data, *end;
2753
2754 len = SvLEN (data_sv);
2755 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2756 data = (uint8_t *)SvPVbyte_nolen (data_sv);
2757 end = data + len + 8;
2758
2759 if (len < 5)
2760 XSRETURN_EMPTY;
2285 2761
2286 if (*data++ != 0) 2762 if (*data++ != 0)
2287 XSRETURN_EMPTY; /* version mismatch */ 2763 XSRETURN_EMPTY; /* version mismatch */
2288 2764
2289 w = *data++ << 8; w |= *data++; 2765 w = *data++ << 8; w |= *data++;
… …
2304 { 2780 {
2305 maprow *row = map_get_row (self, y); 2781 maprow *row = map_get_row (self, y);
2306 2782
2307 for (x = x0; x < x1; x++) 2783 for (x = x0; x < x1; x++)
2308 { 2784 {
2785 uint8_t flags;
2786
2787 if (data + 7 >= end)
2788 XSRETURN_EMPTY;
2789
2309 uint8_t flags = *data++; 2790 flags = *data++;
2310 2791
2311 if (flags) 2792 if (flags)
2312 { 2793 {
2313 mapcell *cell = row_get_cell (row, x); 2794 mapcell *cell = row_get_cell (row, x);
2314 tileid tile[3] = { 0, 0, 0 }; 2795 tileid tile[3] = { 0, 0, 0 };
… …
2317 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2798 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2318 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2799 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2319 2800
2320 if (cell->darkness == 0) 2801 if (cell->darkness == 0)
2321 { 2802 {
2322 cell->darkness = 0; 2803 /*cell->darkness = 0;*/
2804 EXTEND (SP, 3);
2323 2805
2324 for (z = 0; z <= 2; z++) 2806 for (z = 0; z <= 2; z++)
2325 { 2807 {
2326 tileid t = tile [z]; 2808 tileid t = tile [z];
2327 2809
2328 if (t >= self->texs || (t && !self->tex [t].name)) 2810 if (t >= self->texs || (t && !self->tex [t].name))
2329 { 2811 {
2330 XPUSHs (sv_2mortal (newSViv (t))); 2812 PUSHs (sv_2mortal (newSViv (t)));
2331 need_texid (self, t); 2813 need_texid (self, t);
2332 } 2814 }
2333 2815
2334 cell->tile [z] = t; 2816 cell->tile [z] = t;
2335 } 2817 }
… …
2337 } 2819 }
2338 } 2820 }
2339 } 2821 }
2340} 2822}
2341 2823
2342MODULE = CFPlus PACKAGE = CFPlus::RW 2824MODULE = Deliantra::Client PACKAGE = DC::RW
2343 2825
2344CFPlus::RW 2826DC::RW
2345new (SV *class, SV *data_sv) 2827new (SV *klass, SV *data_sv)
2346 CODE: 2828 CODE:
2347{ 2829{
2348 STRLEN datalen; 2830 STRLEN datalen;
2349 char *data = SvPVbyte (data_sv, datalen); 2831 char *data = SvPVbyte (data_sv, datalen);
2350 2832
2351 RETVAL = SDL_RWFromConstMem (data, datalen); 2833 RETVAL = SDL_RWFromConstMem (data, datalen);
2352} 2834}
2353 OUTPUT: 2835 OUTPUT:
2354 RETVAL 2836 RETVAL
2355 2837
2356CFPlus::RW 2838DC::RW
2357new_from_file (SV *class, const char *path, const char *mode = "rb") 2839new_from_file (SV *klass, const char *path, const char *mode = "rb")
2358 CODE: 2840 CODE:
2359 RETVAL = SDL_RWFromFile (path, mode); 2841 RETVAL = SDL_RWFromFile (path, mode);
2360 OUTPUT: 2842 OUTPUT:
2361 RETVAL 2843 RETVAL
2362 2844
2363# fails on win32: 2845# fails on win32:
2364# CFPlus.xs(2268) : error C2059: syntax error : '(' 2846# dc.xs(2268) : error C2059: syntax error : '('
2365#void 2847#void
2366#close (CFPlus::RW self) 2848#close (DC::RW self)
2367# CODE: 2849# CODE:
2368# (self->(close)) (self); 2850# (self->(close)) (self);
2369 2851
2370MODULE = CFPlus PACKAGE = CFPlus::Channel 2852MODULE = Deliantra::Client PACKAGE = DC::Channel
2371 2853
2372PROTOTYPES: DISABLE 2854PROTOTYPES: DISABLE
2373 2855
2374CFPlus::Channel 2856DC::Channel
2375find () 2857find ()
2376 CODE: 2858 CODE:
2377{ 2859{
2378 RETVAL = Mix_GroupAvailable (-1); 2860 RETVAL = Mix_GroupAvailable (-1);
2379 2861
2380 if (RETVAL < 0) 2862 if (RETVAL < 0)
2381 { 2863 {
2382 RETVAL = Mix_GroupOldest (-1); 2864 RETVAL = Mix_GroupOldest (-1);
2383 2865
2384 if (RETVAL < 0) 2866 if (RETVAL < 0)
2867 {
2868 // happens sometimes, maybe it just stopped playing(?)
2869 RETVAL = Mix_GroupAvailable (-1);
2870
2871 if (RETVAL < 0)
2385 XSRETURN_UNDEF; 2872 XSRETURN_UNDEF;
2386 2873 }
2874 else
2387 Mix_HaltChannel (RETVAL); 2875 Mix_HaltChannel (RETVAL);
2388 } 2876 }
2389 2877
2390 Mix_UnregisterAllEffects (RETVAL); 2878 Mix_UnregisterAllEffects (RETVAL);
2391 Mix_Volume (RETVAL, 128); 2879 Mix_Volume (RETVAL, 128);
2392} 2880}
2393 OUTPUT: 2881 OUTPUT:
2394 RETVAL 2882 RETVAL
2395 2883
2396void 2884void
2397halt (CFPlus::Channel self) 2885halt (DC::Channel self)
2398 CODE: 2886 CODE:
2399 Mix_HaltChannel (self); 2887 Mix_HaltChannel (self);
2400 2888
2401void 2889void
2402expire (CFPlus::Channel self, int ticks = -1) 2890expire (DC::Channel self, int ticks = -1)
2403 CODE: 2891 CODE:
2404 Mix_ExpireChannel (self, ticks); 2892 Mix_ExpireChannel (self, ticks);
2405 2893
2406void 2894void
2407fade_out (CFPlus::Channel self, int ticks = -1) 2895fade_out (DC::Channel self, int ticks = -1)
2408 CODE: 2896 CODE:
2409 Mix_FadeOutChannel (self, ticks); 2897 Mix_FadeOutChannel (self, ticks);
2410 2898
2411int 2899int
2412volume (CFPlus::Channel self, int volume) 2900volume (DC::Channel self, int volume)
2413 CODE: 2901 CODE:
2414 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128)); 2902 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2415 OUTPUT: 2903 OUTPUT:
2416 RETVAL 2904 RETVAL
2417 2905
2418void 2906void
2419unregister_all_effects (CFPlus::Channel self) 2907unregister_all_effects (DC::Channel self)
2420 CODE: 2908 CODE:
2421 Mix_UnregisterAllEffects (self); 2909 Mix_UnregisterAllEffects (self);
2422 2910
2423void 2911void
2424set_panning (CFPlus::Channel self, int left, int right) 2912set_panning (DC::Channel self, int left, int right)
2425 CODE: 2913 CODE:
2426 left = CLAMP (left , 0, 255); 2914 left = CLAMP (left , 0, 255);
2427 right = CLAMP (right, 0, 255); 2915 right = CLAMP (right, 0, 255);
2428 Mix_SetPanning (self, left, right); 2916 Mix_SetPanning (self, left, right);
2429 2917
2430void 2918void
2431set_distance (CFPlus::Channel self, int distance) 2919set_distance (DC::Channel self, int distance)
2432 CODE: 2920 CODE:
2433 Mix_SetDistance (self, CLAMP (distance, 0, 255)); 2921 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2434 2922
2435void 2923void
2436set_position (CFPlus::Channel self, int angle, int distance) 2924set_position (DC::Channel self, int angle, int distance)
2437 CODE: 2925 CODE:
2438 2926
2439void 2927void
2440set_position_r (CFPlus::Channel self, int dx, int dy, int maxdistance) 2928set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2441 CODE: 2929 CODE:
2442{ 2930{
2443 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2931 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2444 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2932 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2445 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2933 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2446} 2934}
2447 2935
2448void 2936void
2449set_reverse_stereo (CFPlus::Channel self, int flip) 2937set_reverse_stereo (DC::Channel self, int flip)
2450 CODE: 2938 CODE:
2451 Mix_SetReverseStereo (self, flip); 2939 Mix_SetReverseStereo (self, flip);
2452 2940
2453MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2941MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2454 2942
2455PROTOTYPES: DISABLE 2943PROTOTYPES: DISABLE
2456 2944
2945void
2946decoders ()
2947 PPCODE:
2948#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2949 int i, num = Mix_GetNumChunkDecoders ();
2950 EXTEND (SP, num);
2951 for (i = 0; i < num; ++i)
2952 PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
2953#else
2954 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2955#endif
2956
2457CFPlus::MixChunk 2957DC::MixChunk
2458new (SV *class, CFPlus::RW rwops) 2958new (SV *klass, DC::RW rwops)
2459 CODE: 2959 CODE:
2460 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2960 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2461 OUTPUT: 2961 OUTPUT:
2462 RETVAL 2962 RETVAL
2463 2963
2464void 2964void
2465DESTROY (CFPlus::MixChunk self) 2965DESTROY (DC::MixChunk self)
2466 CODE: 2966 CODE:
2467 Mix_FreeChunk (self); 2967 Mix_FreeChunk (self);
2468 2968
2469int 2969int
2470volume (CFPlus::MixChunk self, int volume = -1) 2970volume (DC::MixChunk self, int volume = -1)
2471 CODE: 2971 CODE:
2472 if (items > 1) 2972 if (items > 1)
2473 volume = CLAMP (volume, 0, 128); 2973 volume = CLAMP (volume, 0, 128);
2474 RETVAL = Mix_VolumeChunk (self, volume); 2974 RETVAL = Mix_VolumeChunk (self, volume);
2475 OUTPUT: 2975 OUTPUT:
2476 RETVAL 2976 RETVAL
2477 2977
2478CFPlus::Channel 2978DC::Channel
2479play (CFPlus::MixChunk self, CFPlus::Channel channel = -1, int loops = 0, int ticks = -1) 2979play (DC::MixChunk self, DC::Channel channel = -1, int loops = 0, int ticks = -1)
2480 CODE: 2980 CODE:
2481{ 2981{
2482 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2982 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2483 2983
2484 if (RETVAL < 0) 2984 if (RETVAL < 0)
… …
2491 } 2991 }
2492} 2992}
2493 OUTPUT: 2993 OUTPUT:
2494 RETVAL 2994 RETVAL
2495 2995
2496MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2996MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2997
2998void
2999decoders ()
3000 PPCODE:
3001#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
3002 int i, num = Mix_GetNumMusicDecoders ();
3003 EXTEND (SP, num);
3004 for (i = 0; i < num; ++i)
3005 PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
3006#else
3007 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
3008#endif
2497 3009
2498int 3010int
2499volume (int volume = -1) 3011volume (int volume = -1)
2500 PROTOTYPE: ;$ 3012 PROTOTYPE: ;$
2501 CODE: 3013 CODE:
… …
2513void 3025void
2514halt () 3026halt ()
2515 CODE: 3027 CODE:
2516 Mix_HaltMusic (); 3028 Mix_HaltMusic ();
2517 3029
3030int
3031playing ()
3032 CODE:
3033 RETVAL = Mix_PlayingMusic ();
3034 OUTPUT:
3035 RETVAL
3036
2518CFPlus::MixMusic 3037DC::MixMusic
2519new (SV *class, CFPlus::RW rwops) 3038new (SV *klass, DC::RW rwops)
2520 CODE: 3039 CODE:
2521 RETVAL = Mix_LoadMUS_RW (rwops); 3040 RETVAL = Mix_LoadMUS_RW (rwops);
2522 OUTPUT: 3041 OUTPUT:
2523 RETVAL 3042 RETVAL
2524 3043
2525void 3044void
2526DESTROY (CFPlus::MixMusic self) 3045DESTROY (DC::MixMusic self)
2527 CODE: 3046 CODE:
2528 Mix_FreeMusic (self); 3047 Mix_FreeMusic (self);
2529 3048
2530int 3049int
2531play (CFPlus::MixMusic self, int loops = -1) 3050play (DC::MixMusic self, int loops = -1)
2532 CODE: 3051 CODE:
2533 RETVAL = Mix_PlayMusic (self, loops); 3052 RETVAL = Mix_PlayMusic (self, loops);
2534 OUTPUT: 3053 OUTPUT:
2535 RETVAL 3054 RETVAL
2536 3055
2537void 3056void
2538fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position) 3057fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2539 CODE: 3058 CODE:
2540 Mix_FadeInMusicPos (self, loops, ms, position); 3059 Mix_FadeInMusicPos (self, loops, ms, position);
2541 3060
2542MODULE = CFPlus PACKAGE = CFPlus::OpenGL 3061MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2543 3062
2544PROTOTYPES: ENABLE 3063PROTOTYPES: ENABLE
2545 3064
2546BOOT: 3065BOOT:
2547{ 3066{
2548 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 3067 HV *stash = gv_stashpv ("DC::OpenGL", 1);
2549 static const struct { 3068 static const struct {
2550 const char *name; 3069 const char *name;
2551 IV iv; 3070 IV iv;
2552 } *civ, const_iv[] = { 3071 } *civ, const_iv[] = {
2553# define const_iv(name) { # name, (IV)name } 3072# define const_iv(name) { # name, (IV)name }
2554 const_iv (GL_VENDOR), 3073 const_iv (GL_VENDOR),
2555 const_iv (GL_VERSION), 3074 const_iv (GL_VERSION),
2556 const_iv (GL_EXTENSIONS), 3075 const_iv (GL_EXTENSIONS),
3076 const_iv (GL_MAX_TEXTURE_UNITS),
2557 const_iv (GL_COLOR_MATERIAL), 3077 const_iv (GL_COLOR_MATERIAL),
2558 const_iv (GL_SMOOTH), 3078 const_iv (GL_SMOOTH),
2559 const_iv (GL_FLAT), 3079 const_iv (GL_FLAT),
2560 const_iv (GL_DITHER), 3080 const_iv (GL_DITHER),
2561 const_iv (GL_BLEND), 3081 const_iv (GL_BLEND),
… …
2573 const_iv (GL_ZERO), 3093 const_iv (GL_ZERO),
2574 const_iv (GL_SRC_ALPHA), 3094 const_iv (GL_SRC_ALPHA),
2575 const_iv (GL_DST_ALPHA), 3095 const_iv (GL_DST_ALPHA),
2576 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3096 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2577 const_iv (GL_ONE_MINUS_DST_ALPHA), 3097 const_iv (GL_ONE_MINUS_DST_ALPHA),
3098 const_iv (GL_SRC_COLOR),
3099 const_iv (GL_DST_COLOR),
3100 const_iv (GL_ONE_MINUS_SRC_COLOR),
3101 const_iv (GL_ONE_MINUS_DST_COLOR),
2578 const_iv (GL_SRC_ALPHA_SATURATE), 3102 const_iv (GL_SRC_ALPHA_SATURATE),
2579 const_iv (GL_RGB), 3103 const_iv (GL_RGB),
2580 const_iv (GL_RGBA), 3104 const_iv (GL_RGBA),
2581 const_iv (GL_RGBA4), 3105 const_iv (GL_RGBA4),
2582 const_iv (GL_RGBA8), 3106 const_iv (GL_RGBA8),
… …
2650 const_iv (GL_NICEST), 3174 const_iv (GL_NICEST),
2651 const_iv (GL_V2F), 3175 const_iv (GL_V2F),
2652 const_iv (GL_V3F), 3176 const_iv (GL_V3F),
2653 const_iv (GL_T2F_V3F), 3177 const_iv (GL_T2F_V3F),
2654 const_iv (GL_T2F_N3F_V3F), 3178 const_iv (GL_T2F_N3F_V3F),
3179 const_iv (GL_FUNC_ADD),
3180 const_iv (GL_FUNC_SUBTRACT),
3181 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2655# undef const_iv 3182# undef const_iv
2656 }; 3183 };
2657 3184
2658 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3185 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
2659 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3186 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2660 3187
2661 texture_av = newAV (); 3188 texture_av = newAV ();
2662 AvREAL_off (texture_av); 3189 AvREAL_off (texture_av);
2663} 3190}
2664 3191
… …
2666disable_GL_EXT_blend_func_separate () 3193disable_GL_EXT_blend_func_separate ()
2667 CODE: 3194 CODE:
2668 gl.BlendFuncSeparate = 0; 3195 gl.BlendFuncSeparate = 0;
2669 gl.BlendFuncSeparateEXT = 0; 3196 gl.BlendFuncSeparateEXT = 0;
2670 3197
2671char * 3198void
3199apple_nvidia_bug (int enable)
3200
3201const char *
2672gl_vendor () 3202gl_vendor ()
2673 CODE: 3203 CODE:
2674 RETVAL = (char *)glGetString (GL_VENDOR); 3204 RETVAL = (const char *)glGetString (GL_VENDOR);
2675 OUTPUT: 3205 OUTPUT:
2676 RETVAL 3206 RETVAL
2677 3207
2678char * 3208const char *
2679gl_version () 3209gl_version ()
2680 CODE: 3210 CODE:
2681 RETVAL = (char *)glGetString (GL_VERSION); 3211 RETVAL = (const char *)glGetString (GL_VERSION);
2682 OUTPUT: 3212 OUTPUT:
2683 RETVAL 3213 RETVAL
2684 3214
2685char * 3215const char *
2686gl_extensions () 3216gl_extensions ()
2687 CODE: 3217 CODE:
2688 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3218 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2689 OUTPUT: 3219 OUTPUT:
2690 RETVAL 3220 RETVAL
2691 3221
2692const char *glGetString (GLenum pname) 3222const char *glGetString (GLenum pname)
3223 CODE:
3224 RETVAL = (const char *)glGetString (pname);
3225 OUTPUT:
3226 RETVAL
2693 3227
2694GLint glGetInteger (GLenum pname) 3228GLint glGetInteger (GLenum pname)
2695 CODE: 3229 CODE:
2696 glGetIntegerv (pname, &RETVAL); 3230 glGetIntegerv (pname, &RETVAL);
2697 OUTPUT: 3231 OUTPUT:
… …
2705 3239
2706int glGetError () 3240int glGetError ()
2707 3241
2708void glFinish () 3242void glFinish ()
2709 3243
3244void glFlush ()
3245
2710void glClear (int mask) 3246void glClear (int mask)
2711 3247
2712void glClearColor (float r, float g, float b, float a = 1.0) 3248void glClearColor (float r, float g, float b, float a = 1.0)
2713 PROTOTYPE: @ 3249 PROTOTYPE: @
2714 3250
… …
2723void glBlendFunc (int sfactor, int dfactor) 3259void glBlendFunc (int sfactor, int dfactor)
2724 3260
2725void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3261void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2726 CODE: 3262 CODE:
2727 gl_BlendFuncSeparate (sa, da, saa, daa); 3263 gl_BlendFuncSeparate (sa, da, saa, daa);
3264
3265# void glBlendEquation (int se)
2728 3266
2729void glDepthMask (int flag) 3267void glDepthMask (int flag)
2730 3268
2731void glLogicOp (int opcode) 3269void glLogicOp (int opcode)
2732 3270
… …
2767void glRotate (float angle, float x, float y, float z) 3305void glRotate (float angle, float x, float y, float z)
2768 CODE: 3306 CODE:
2769 glRotatef (angle, x, y, z); 3307 glRotatef (angle, x, y, z);
2770 3308
2771void glColor (float r, float g, float b, float a = 1.0) 3309void glColor (float r, float g, float b, float a = 1.0)
3310 PROTOTYPE: @
2772 ALIAS: 3311 ALIAS:
2773 glColor_premultiply = 1 3312 glColor_premultiply = 1
2774 CODE: 3313 CODE:
2775 if (ix) 3314 if (ix)
2776 { 3315 {
… …
2846void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column) 3385void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2847 CODE: 3386 CODE:
2848 if (gl.SeparableFilter2D) 3387 if (gl.SeparableFilter2D)
2849 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3388 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2850 3389
2851void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data) 3390void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data = 0)
2852 3391
2853void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 3392void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2854 3393
2855void glDrawPixels (int width, int height, int format, int type, char *pixels) 3394void glDrawPixels (int width, int height, int format, int type, char *pixels)
2856 3395
… …
2882 3421
2883void glEndList () 3422void glEndList ()
2884 3423
2885void glCallList (int list) 3424void glCallList (int list)
2886 3425
2887MODULE = CFPlus PACKAGE = CFPlus::UI::Base 3426void c_init ()
3427 CODE:
3428 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3429 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3430
3431MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2888 3432
2889PROTOTYPES: DISABLE 3433PROTOTYPES: DISABLE
2890 3434
2891void 3435void
2892find_widget (SV *self, NV x, NV y) 3436find_widget (SV *self, NV x, NV y)
2893 PPCODE: 3437 PPCODE:
2894{ 3438{
2895 if (within_widget (self, x, y)) 3439 if (within_widget (self, x, y))
2896 XPUSHs (self); 3440 XPUSHs (self);
2897} 3441}
2898 3442
2899BOOT: 3443BOOT:
2900{ 3444{
2901 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV); 3445 hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
2902 3446
2903 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV); 3447 draw_x_gv = gv_fetchpv ("DC::UI::Base::draw_x", 1, SVt_NV);
2904 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV); 3448 draw_y_gv = gv_fetchpv ("DC::UI::Base::draw_y", 1, SVt_NV);
2905 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV); 3449 draw_w_gv = gv_fetchpv ("DC::UI::Base::draw_w", 1, SVt_NV);
2906 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV); 3450 draw_h_gv = gv_fetchpv ("DC::UI::Base::draw_h", 1, SVt_NV);
2907} 3451}
2908 3452
2909void 3453void
2910draw (SV *self) 3454draw (SV *self)
2911 CODE: 3455 CODE:
2912{ 3456{
2913 HV *hv; 3457 HV *hv;
2914 SV **svp; 3458 SV **svp;
2915 NV x, y, w, h; 3459 NV x, y, w, h;
2916 SV *draw_x_sv = GvSV (draw_x_gv); 3460 SV *draw_x_sv = GvSV (draw_x_gv);
2917 SV *draw_y_sv = GvSV (draw_y_gv); 3461 SV *draw_y_sv = GvSV (draw_y_gv);
2918 SV *draw_w_sv = GvSV (draw_w_gv); 3462 SV *draw_w_sv = GvSV (draw_w_gv);
2919 SV *draw_h_sv = GvSV (draw_h_gv); 3463 SV *draw_h_sv = GvSV (draw_h_gv);
2920 double draw_x, draw_y; 3464 double draw_x, draw_y;
2921 3465
2922 if (!SvROK (self)) 3466 if (!SvROK (self))
2923 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self)); 3467 croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
2924 3468
2925 hv = (HV *)SvRV (self); 3469 hv = (HV *)SvRV (self);
2926 3470
2927 if (SvTYPE (hv) != SVt_PVHV) 3471 if (SvTYPE (hv) != SVt_PVHV)
2928 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self)); 3472 croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
2929 3473
2930 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.; 3474 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2931 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.; 3475 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2932 3476
2933 if (!h || !w) 3477 if (!h || !w)

Diff Legend

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