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.235 by root, Tue Aug 28 01:23:47 2007 UTC vs.
Revision 1.327 by root, Sun Nov 18 12:01:50 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 std::vector<tileid> tile;
232 int texs; maptex *tex; // [tileid] 293 std::vector<maptex> tex;
233 294
234 int32_t rows; 295 int32_t rows;
235 maprow *row; 296 maprow *row;
236} *CFPlus__Map; 297
298 ~mapgrid ()
299 {
300 clear_cells ();
301 }
302
303 void clear_cells ();
304};
305
306typedef mapgrid *DC__Map;
237 307
238static char * 308static char *
239prepend (char *ptr, int sze, int inc) 309prepend (char *ptr, int sze, int inc)
240{ 310{
241 char *p; 311 char *p;
… …
258} 328}
259 329
260#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 330#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)) 331#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
262 332
263static void
264need_facenum (struct map *self, faceid face)
265{
266 while (self->faces <= face)
267 {
268 Append (tileid, self->face2tile, self->faces, self->faces);
269 self->faces *= 2;
270 }
271}
272
273static void
274need_texid (struct map *self, int texid)
275{
276 while (self->texs <= texid)
277 {
278 Append (maptex, self->tex, self->texs, self->texs);
279 self->texs *= 2;
280 }
281}
282
283static maprow * 333static maprow *
284map_get_row (CFPlus__Map self, int y) 334map_get_row (mapgrid *self, int y)
285{ 335{
286 if (0 > y) 336 if (0 > y)
287 { 337 {
288 int extend = - y + MAP_EXTEND_Y; 338 int extend = - y + MAP_EXTEND_Y;
289 Prepend (maprow, self->row, self->rows, extend); 339 Prepend (maprow, self->row, self->rows, extend);
… …
327 377
328 return row->col + (x - row->c0); 378 return row->col + (x - row->c0);
329} 379}
330 380
331static mapcell * 381static mapcell *
332map_get_cell (CFPlus__Map self, int x, int y) 382map_get_cell (mapgrid *self, int x, int y)
333{ 383{
334 return row_get_cell (map_get_row (self, y), x); 384 return row_get_cell (map_get_row (self, y), x);
335} 385}
336 386
387void mapgrid::clear_cells ()
388{
389 int r;
390
391 for (r = 0; r < rows; r++)
392 Safefree (row[r].col);
393
394 Safefree (row);
395
396 x = 0;
397 y = 0;
398 ox = 0;
399 oy = 0;
400 row = 0;
401 rows = 0;
402}
403
404#define CELL_CLEAR(cell) \
405 do { \
406 if ((cell)->player) \
407 (cell)->tile [2] = 0; \
408 (cell)->darkness = 0; \
409 (cell)->stat_hp = 0; \
410 (cell)->flags = 0; \
411 (cell)->player = 0; \
412 } while (0)
413
337static void 414static void
338map_clear (CFPlus__Map self)
339{
340 int r;
341
342 for (r = 0; r < self->rows; r++)
343 Safefree (self->row[r].col);
344
345 Safefree (self->row);
346
347 self->x = 0;
348 self->y = 0;
349 self->ox = 0;
350 self->oy = 0;
351 self->row = 0;
352 self->rows = 0;
353}
354
355static void
356map_blank (CFPlus__Map self, int x0, int y0, int w, int h) 415map_blank (mapgrid *self, int x0, int y0, int w, int h)
357{ 416{
358 int x, y; 417 int x, y;
359 maprow *row; 418 maprow *row;
360 mapcell *cell; 419 mapcell *cell;
361 420
… …
373 if (x >= row->c1) 432 if (x >= row->c1)
374 break; 433 break;
375 434
376 cell = row->col + x - row->c0; 435 cell = row->col + x - row->c0;
377 436
378 cell->darkness = 0; 437 CELL_CLEAR (cell);
379 cell->stat_hp = 0;
380 cell->flags = 0;
381 cell->player = 0;
382 } 438 }
383 } 439 }
384} 440}
385 441
386typedef struct { 442struct smooth_key
443{
387 tileid tile; 444 tileid tile;
388 uint8_t x, y, level; 445 uint8_t x, y, level;
389} smooth_key; 446
447 bool operator == (const smooth_key &o) const
448 {
449 return tile == o.tile && x == o.x && y == o.y && level == o.level;
450 }
451};
452
453typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
454
455namespace std {
456 template <>
457 struct hash<smooth_key>
458 {
459 size_t operator () (const smooth_key &v) const
460 {
461 return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
462 }
463 };
464}
390 465
391static void 466static void
392smooth_or_bits (HV *hv, smooth_key *key, IV bits) 467smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
393{ 468{
394 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1); 469 auto &&it = h.find (key);
395 470
396 if (SvIOK (*sv)) 471 if (it == h.end ())
397 SvIV_set (*sv, SvIVX (*sv) | bits); 472 h.insert (std::make_pair (key, bits));
398 else 473 else
399 sv_setiv (*sv, bits); 474 it->second |= bits;
400} 475}
401 476
402static void 477static void
403music_finished (void) 478music_finished (void)
404{ 479{
… …
421 ev.code = 1; 496 ev.code = 1;
422 ev.data1 = (void *)(long)channel; 497 ev.data1 = (void *)(long)channel;
423 ev.data2 = 0; 498 ev.data2 = 0;
424 499
425 SDL_PushEvent ((SDL_Event *)&ev); 500 SDL_PushEvent ((SDL_Event *)&ev);
501}
502
503// approximately divide by 255
504static unsigned int
505div255 (unsigned int n)
506{
507 return (n + (n >> 8)) >> 8;
426} 508}
427 509
428static unsigned int 510static unsigned int
429minpot (unsigned int n) 511minpot (unsigned int n)
430{ 512{
… …
498 return 0; 580 return 0;
499 581
500 return 1; 582 return 1;
501} 583}
502 584
503MODULE = CFPlus PACKAGE = CFPlus 585/******************************************************************************/
586
587/* process keyboard modifiers */
588static int
589mod_munge (int mod)
590{
591 mod &= MOD_MASK;
592
593 if (mod & (KMOD_META | KMOD_ALT))
594 mod |= KMOD_LRAM;
595
596 return mod;
597}
598
599static void
600deliantra_main (SV *real_main)
601{
602 dSP;
603
604 PUSHMARK (SP);
605 call_sv (real_main, G_DISCARD | G_VOID);
606}
607
608#ifdef __MACOSX__
609 static SV *real_main;
610
611 /* to due surprising braindamage on the side of SDL design, we
612 * do some mind-boggling hack here: SDL requires a custom main()
613 * on OS X, so... we provide one and call the original main(), which,
614 * due to shared library magic, calls -lSDLmain's main, not perl's main,
615 * and which calls our main (== SDL_main) back.
616 */
617 extern C_LINKAGE int
618 main (int argc, char *argv[])
619 {
620 deliantra_main (real_main);
621 }
622
623 #undef main
624
625 extern C_LINKAGE int main (int argc, char *argv[]);
626
627 static void
628 SDL_main_hack (SV *real_main_)
629 {
630 real_main = real_main_;
631
632 char *argv[] = { "deliantra client", 0 };
633 (main) (1, argv);
634 }
635#else
636 static void
637 SDL_main_hack (SV *real_main)
638 {
639 deliantra_main (real_main);
640 }
641#endif
642
643MODULE = Deliantra::Client PACKAGE = DC
504 644
505PROTOTYPES: ENABLE 645PROTOTYPES: ENABLE
506 646
507BOOT: 647BOOT:
508{ 648{
509 HV *stash = gv_stashpv ("CFPlus", 1); 649 HV *stash = gv_stashpv ("DC", 1);
510 static const struct { 650 static const struct {
511 const char *name; 651 const char *name;
512 IV iv; 652 IV iv;
513 } *civ, const_iv[] = { 653 } *civ, const_iv[] = {
514# define const_iv(name) { # name, (IV)name } 654# define const_iv(name) { # name, (IV)name }
… …
535 const_iv (SDL_USEREVENT), 675 const_iv (SDL_USEREVENT),
536 676
537 const_iv (SDL_APPINPUTFOCUS), 677 const_iv (SDL_APPINPUTFOCUS),
538 const_iv (SDL_APPMOUSEFOCUS), 678 const_iv (SDL_APPMOUSEFOCUS),
539 const_iv (SDL_APPACTIVE), 679 const_iv (SDL_APPACTIVE),
680
681
682 const_iv (SDLK_UNKNOWN),
683 const_iv (SDLK_FIRST),
684 const_iv (SDLK_BACKSPACE),
685 const_iv (SDLK_TAB),
686 const_iv (SDLK_CLEAR),
687 const_iv (SDLK_RETURN),
688 const_iv (SDLK_PAUSE),
689 const_iv (SDLK_ESCAPE),
690 const_iv (SDLK_SPACE),
691 const_iv (SDLK_EXCLAIM),
692 const_iv (SDLK_QUOTEDBL),
693 const_iv (SDLK_HASH),
694 const_iv (SDLK_DOLLAR),
695 const_iv (SDLK_AMPERSAND),
696 const_iv (SDLK_QUOTE),
697 const_iv (SDLK_LEFTPAREN),
698 const_iv (SDLK_RIGHTPAREN),
699 const_iv (SDLK_ASTERISK),
700 const_iv (SDLK_PLUS),
701 const_iv (SDLK_COMMA),
702 const_iv (SDLK_MINUS),
703 const_iv (SDLK_PERIOD),
704 const_iv (SDLK_SLASH),
705 const_iv (SDLK_0),
706 const_iv (SDLK_1),
707 const_iv (SDLK_2),
708 const_iv (SDLK_3),
709 const_iv (SDLK_4),
710 const_iv (SDLK_5),
711 const_iv (SDLK_6),
712 const_iv (SDLK_7),
713 const_iv (SDLK_8),
714 const_iv (SDLK_9),
715 const_iv (SDLK_COLON),
716 const_iv (SDLK_SEMICOLON),
717 const_iv (SDLK_LESS),
718 const_iv (SDLK_EQUALS),
719 const_iv (SDLK_GREATER),
720 const_iv (SDLK_QUESTION),
721 const_iv (SDLK_AT),
722
723 const_iv (SDLK_LEFTBRACKET),
724 const_iv (SDLK_BACKSLASH),
725 const_iv (SDLK_RIGHTBRACKET),
726 const_iv (SDLK_CARET),
727 const_iv (SDLK_UNDERSCORE),
728 const_iv (SDLK_BACKQUOTE),
729 const_iv (SDLK_DELETE),
540 730
541 const_iv (SDLK_FIRST), 731 const_iv (SDLK_FIRST),
542 const_iv (SDLK_LAST), 732 const_iv (SDLK_LAST),
543 const_iv (SDLK_KP0), 733 const_iv (SDLK_KP0),
544 const_iv (SDLK_KP1), 734 const_iv (SDLK_KP1),
… …
619 const_iv (KMOD_LMETA), 809 const_iv (KMOD_LMETA),
620 const_iv (KMOD_RMETA), 810 const_iv (KMOD_RMETA),
621 const_iv (KMOD_NUM), 811 const_iv (KMOD_NUM),
622 const_iv (KMOD_CAPS), 812 const_iv (KMOD_CAPS),
623 const_iv (KMOD_MODE), 813 const_iv (KMOD_MODE),
814
815 const_iv (KMOD_LRAM),
816
817 const_iv (MIX_DEFAULT_FORMAT),
818
819 const_iv (SDL_INIT_TIMER),
820 const_iv (SDL_INIT_AUDIO),
821 const_iv (SDL_INIT_VIDEO),
822 const_iv (SDL_INIT_CDROM),
823 const_iv (SDL_INIT_JOYSTICK),
824 const_iv (SDL_INIT_EVERYTHING),
825 const_iv (SDL_INIT_NOPARACHUTE),
826 const_iv (SDL_INIT_EVENTTHREAD),
827
828 const_iv (SDL_GL_RED_SIZE),
829 const_iv (SDL_GL_GREEN_SIZE),
830 const_iv (SDL_GL_BLUE_SIZE),
831 const_iv (SDL_GL_ALPHA_SIZE),
832 const_iv (SDL_GL_DOUBLEBUFFER),
833 const_iv (SDL_GL_BUFFER_SIZE),
834 const_iv (SDL_GL_DEPTH_SIZE),
835 const_iv (SDL_GL_STENCIL_SIZE),
836 const_iv (SDL_GL_ACCUM_RED_SIZE),
837 const_iv (SDL_GL_ACCUM_GREEN_SIZE),
838 const_iv (SDL_GL_ACCUM_BLUE_SIZE),
839 const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
840 const_iv (SDL_GL_STEREO),
841 const_iv (SDL_GL_MULTISAMPLEBUFFERS),
842 const_iv (SDL_GL_MULTISAMPLESAMPLES),
843 const_iv (SDL_GL_ACCELERATED_VISUAL),
844 const_iv (SDL_GL_SWAP_CONTROL),
845
846 const_iv (FOW_DARKNESS)
624# undef const_iv 847# undef const_iv
625 }; 848 };
626 849
627 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 850 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
628 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 851 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
629 852
630 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK); 853 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
631 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE); 854 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
632} 855}
633 856
… …
649NV ceil (NV x) 872NV ceil (NV x)
650 873
651IV minpot (UV n) 874IV minpot (UV n)
652 875
653IV popcount (UV n) 876IV popcount (UV n)
877
878NV distance (NV dx, NV dy)
879 CODE:
880 RETVAL = pow (dx * dx + dy * dy, 0.5);
881 OUTPUT:
882 RETVAL
654 883
655void 884void
656pango_init () 885pango_init ()
657 CODE: 886 CODE:
658{ 887{
659 opengl_fontmap = pango_opengl_font_map_new (); 888 opengl_fontmap = pango_opengl_font_map_new ();
660 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 889 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
661 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 890 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
891 /*pango_context_set_font_description (opengl_context, default_font);*/
892#if PANGO_VERSION_CHECK (1, 15, 2)
893 pango_context_set_language (opengl_context, pango_language_from_string ("en"));
894 /*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
895#endif
662} 896}
663 897
664char *
665SDL_GetError () 898char *SDL_GetError ()
666 899
667int 900void SDL_main_hack (SV *real_main)
668SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 901 PROTOTYPE: &
669 902
670void 903int SDL_Init (U32 flags)
904
905int SDL_InitSubSystem (U32 flags)
906
907void SDL_QuitSubSystem (U32 flags)
908
671SDL_Quit () 909void SDL_Quit ()
910
911int SDL_GL_SetAttribute (int attr, int value)
912 C_ARGS: (SDL_GLattr)attr, value
913
914int SDL_GL_GetAttribute (int attr)
915 CODE:
916 if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
917 XSRETURN_UNDEF;
918 OUTPUT:
919 RETVAL
672 920
673void 921void
674SDL_ListModes (int rgb, int alpha) 922SDL_ListModes (int rgb, int alpha)
675 PPCODE: 923 PPCODE:
676{ 924{
… …
688 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 936 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
689 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0); 937 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
690 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 938 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
691 939
692 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 940 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
693#if SDL_VERSION_ATLEAST(1,2,10)
694 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
695 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 941 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
696#endif
697 942
698 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 943 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
699 944
700 if (m && m != (SDL_Rect **)-1) 945 if (m && m != (SDL_Rect **)-1)
701 while (*m) 946 while (*m)
702 { 947 {
703 if ((*m)->w >= 640 && (*m)->h >= 480) 948 if ((*m)->w >= 400 && (*m)->h >= 300)
704 { 949 {
705 AV *av = newAV (); 950 AV *av = newAV ();
706 av_push (av, newSViv ((*m)->w)); 951 av_push (av, newSViv ((*m)->w));
707 av_push (av, newSViv ((*m)->h)); 952 av_push (av, newSViv ((*m)->h));
708 av_push (av, newSViv (rgb)); 953 av_push (av, newSViv (rgb));
… …
731 ); 976 );
732 977
733 if (RETVAL) 978 if (RETVAL)
734 { 979 {
735 av_clear (texture_av); 980 av_clear (texture_av);
736
737 SDL_WM_SetCaption ("Crossfire TRT Client " VERSION, "Crossfire TRT");
738#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 981#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
739#include "glfunc.h" 982#include "glfunc.h"
740#undef GL_FUNC 983#undef GL_FUNC
984 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
985 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
741 } 986 }
742} 987}
743 OUTPUT: 988 OUTPUT:
744 RETVAL 989 RETVAL
990
991void
992SDL_WM_SetCaption (const char *title, const char *icon)
745 993
746void 994void
747SDL_GL_SwapBuffers () 995SDL_GL_SwapBuffers ()
748 996
749char * 997char *
750SDL_GetKeyName (int sym) 998SDL_GetKeyName (int sym)
999 C_ARGS: (SDLKey)sym
751 1000
752int 1001int
753SDL_GetAppState () 1002SDL_GetAppState ()
754 1003
1004int
1005SDL_GetModState ()
1006
1007int
1008SDL_WaitEvent ()
1009 C_ARGS: 0
1010
755void 1011void
1012SDL_PumpEvents ()
1013
1014void
756poll_events () 1015peep_events ()
757 PPCODE: 1016 PPCODE:
758{ 1017{
759 SDL_Event ev; 1018 SDL_Event ev;
760 1019
761 SDL_PumpEvents (); 1020 SDL_PumpEvents ();
… …
768 { 1027 {
769 case SDL_KEYDOWN: 1028 case SDL_KEYDOWN:
770 case SDL_KEYUP: 1029 case SDL_KEYUP:
771 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 1030 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
772 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 1031 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
773 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 1032 hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
774 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */ 1033 hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
775 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 1034 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
776 break; 1035 break;
777 1036
778 case SDL_ACTIVEEVENT: 1037 case SDL_ACTIVEEVENT:
779 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 1038 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
… …
797 x = ev.motion.x; 1056 x = ev.motion.x;
798 y = ev.motion.y; 1057 y = ev.motion.y;
799 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)); 1058 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
800 } 1059 }
801 1060
802 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1061 hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
803 hv_store (hv, "state", 5, newSViv (state), 0); 1062 hv_store (hv, "state", 5, newSViv (state), 0);
804 hv_store (hv, "x", 1, newSViv (x), 0); 1063 hv_store (hv, "x", 1, newSViv (x), 0);
805 hv_store (hv, "y", 1, newSViv (y), 0); 1064 hv_store (hv, "y", 1, newSViv (y), 0);
806 hv_store (hv, "xrel", 4, newSViv (xrel), 0); 1065 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
807 hv_store (hv, "yrel", 4, newSViv (yrel), 0); 1066 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
808 } 1067 }
809 break; 1068 break;
810 1069
811 case SDL_MOUSEBUTTONDOWN: 1070 case SDL_MOUSEBUTTONDOWN:
812 case SDL_MOUSEBUTTONUP: 1071 case SDL_MOUSEBUTTONUP:
813 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 1072 hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
814 1073
815 hv_store (hv, "button", 6, newSViv (ev.button.button), 0); 1074 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
816 hv_store (hv, "state", 5, newSViv (ev.button.state), 0); 1075 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
817 hv_store (hv, "x", 1, newSViv (ev.button.x), 0); 1076 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
818 hv_store (hv, "y", 1, newSViv (ev.button.y), 0); 1077 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
… …
823 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0); 1082 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
824 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0); 1083 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
825 break; 1084 break;
826 } 1085 }
827 1086
828 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1)))); 1087 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
829 } 1088 }
830} 1089}
831 1090
1091char *
1092SDL_AudioDriverName ()
1093 CODE:
1094{
1095 char buf [256];
1096 if (!SDL_AudioDriverName (buf, sizeof (buf)))
1097 XSRETURN_UNDEF;
1098
1099 RETVAL = buf;
1100}
1101 OUTPUT:
1102 RETVAL
1103
832int 1104int
833Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 1024) 1105Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
834 POSTCALL: 1106 POSTCALL:
835 Mix_HookMusicFinished (music_finished); 1107 Mix_HookMusicFinished (music_finished);
836 Mix_ChannelFinished (channel_finished); 1108 Mix_ChannelFinished (channel_finished);
1109
1110void
1111Mix_QuerySpec ()
1112 PPCODE:
1113{
1114 int freq, channels;
1115 Uint16 format;
1116
1117 if (Mix_QuerySpec (&freq, &format, &channels))
1118 {
1119 EXTEND (SP, 3);
1120 PUSHs (sv_2mortal (newSViv (freq)));
1121 PUSHs (sv_2mortal (newSViv (format)));
1122 PUSHs (sv_2mortal (newSViv (channels)));
1123 }
1124}
837 1125
838void 1126void
839Mix_CloseAudio () 1127Mix_CloseAudio ()
840 1128
841int 1129int
… …
876 } 1164 }
877 } 1165 }
878#endif 1166#endif
879} 1167}
880 1168
881void 1169int
882add_font (char *file) 1170add_font (char *file)
883 CODE: 1171 CODE:
884 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1172 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1173 OUTPUT:
1174 RETVAL
1175
1176void
1177IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
1178
1179# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
1180void
1181Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
885 1182
886void 1183void
887load_image_inline (SV *image_) 1184load_image_inline (SV *image_)
888 ALIAS: 1185 ALIAS:
889 load_image_file = 1 1186 load_image_file = 1
… …
935 1232
936 SDL_LockSurface (surface2); 1233 SDL_LockSurface (surface2);
937 EXTEND (SP, 6); 1234 EXTEND (SP, 6);
938 PUSHs (sv_2mortal (newSViv (surface2->w))); 1235 PUSHs (sv_2mortal (newSViv (surface2->w)));
939 PUSHs (sv_2mortal (newSViv (surface2->h))); 1236 PUSHs (sv_2mortal (newSViv (surface2->h)));
940 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1237 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
941 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 1238 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
942 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1239 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
943 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1240 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
944 SDL_UnlockSurface (surface2); 1241 SDL_UnlockSurface (surface2);
945 1242
… …
975void 1272void
976error (char *message) 1273error (char *message)
977 CODE: 1274 CODE:
978 fprintf (stderr, "ERROR: %s\n", message); 1275 fprintf (stderr, "ERROR: %s\n", message);
979#ifdef _WIN32 1276#ifdef _WIN32
980 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR); 1277 MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
981#endif 1278#endif
982 1279
983void 1280void
984fatal (char *message) 1281fatal (char *message)
985 CODE: 1282 CODE:
986 fprintf (stderr, "FATAL: %s\n", message); 1283 fprintf (stderr, "FATAL: %s\n", message);
987#ifdef _WIN32 1284#ifdef _WIN32
988 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 1285 MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
989#endif 1286#endif
990 _exit (1); 1287 _exit (1);
991 1288
992void 1289void
993_exit (int retval = 0) 1290_exit (int retval = 0)
… …
1005#if DEBUG 1302#if DEBUG
1006 VALGRIND_DO_LEAK_CHECK; 1303 VALGRIND_DO_LEAK_CHECK;
1007#endif 1304#endif
1008} 1305}
1009 1306
1010MODULE = CFPlus PACKAGE = CFPlus::Font 1307int
1308SvREFCNT (SV *sv)
1309 CODE:
1310 RETVAL = SvREFCNT (sv);
1311 OUTPUT:
1312 RETVAL
1313
1314MODULE = Deliantra::Client PACKAGE = DC::Font
1011 1315
1012PROTOTYPES: DISABLE 1316PROTOTYPES: DISABLE
1013 1317
1014CFPlus::Font 1318DC::Font
1015new_from_file (SV *class, char *path, int id = 0) 1319new_from_file (SV *klass, char *path, int id = 0)
1016 CODE: 1320 CODE:
1017{ 1321{
1018 int count; 1322 int count;
1019 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1323 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1020 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1324 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1022} 1326}
1023 OUTPUT: 1327 OUTPUT:
1024 RETVAL 1328 RETVAL
1025 1329
1026void 1330void
1027DESTROY (CFPlus::Font self) 1331DESTROY (DC::Font self)
1028 CODE: 1332 CODE:
1029 pango_font_description_free (self); 1333 pango_font_description_free (self);
1030 1334
1031void 1335void
1032make_default (CFPlus::Font self) 1336make_default (DC::Font self)
1033 PROTOTYPE: $ 1337 PROTOTYPE: $
1034 CODE: 1338 CODE:
1035 default_font = self; 1339 default_font = self;
1036 1340
1037MODULE = CFPlus PACKAGE = CFPlus::Layout 1341MODULE = Deliantra::Client PACKAGE = DC::Layout
1038 1342
1039PROTOTYPES: DISABLE 1343PROTOTYPES: DISABLE
1040 1344
1041void 1345void
1042reset_glyph_cache () 1346glyph_cache_backup ()
1043 PROTOTYPE: 1347 PROTOTYPE:
1044 CODE: 1348 CODE:
1349 tc_backup ();
1350
1351void
1352glyph_cache_restore ()
1353 PROTOTYPE:
1354 CODE:
1045 tc_clear (); 1355 tc_restore ();
1046 1356
1047CFPlus::Layout 1357DC::Layout
1048new (SV *class) 1358new (SV *klass)
1049 CODE: 1359 CODE:
1050 New (0, RETVAL, 1, struct cf_layout); 1360 RETVAL = new cf_layout;
1051 1361
1052 RETVAL->pl = pango_layout_new (opengl_context); 1362 RETVAL->pl = pango_layout_new (opengl_context);
1053 RETVAL->r = 1.; 1363 RETVAL->r = 1.;
1054 RETVAL->g = 1.; 1364 RETVAL->g = 1.;
1055 RETVAL->b = 1.; 1365 RETVAL->b = 1.;
1056 RETVAL->a = 1.; 1366 RETVAL->a = 1.;
1057 RETVAL->base_height = MIN_FONT_HEIGHT; 1367 RETVAL->base_height = MIN_FONT_HEIGHT;
1058 RETVAL->font = 0; 1368 RETVAL->font = 0;
1059 RETVAL->rc = rc_alloc ();
1060 1369
1061 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1370 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1062 layout_update_font (RETVAL); 1371 layout_update_font (RETVAL);
1063 OUTPUT: 1372 OUTPUT:
1064 RETVAL 1373 RETVAL
1065 1374
1066void 1375void
1067DESTROY (CFPlus::Layout self) 1376DESTROY (DC::Layout self)
1068 CODE: 1377 CODE:
1069 g_object_unref (self->pl); 1378 g_object_unref (self->pl);
1070 rc_free (self->rc);
1071 Safefree (self); 1379 delete self;
1072 1380
1073void 1381void
1074set_text (CFPlus::Layout self, SV *text_) 1382set_text (DC::Layout self, SV *text_)
1075 CODE: 1383 CODE:
1076{ 1384{
1077 STRLEN textlen; 1385 STRLEN textlen;
1078 char *text = SvPVutf8 (text_, textlen); 1386 char *text = SvPVutf8 (text_, textlen);
1079 1387
1080 pango_layout_set_text (self->pl, text, textlen); 1388 pango_layout_set_text (self->pl, text, textlen);
1081} 1389}
1082 1390
1083void 1391void
1084set_markup (CFPlus::Layout self, SV *text_) 1392set_markup (DC::Layout self, SV *text_)
1085 CODE: 1393 CODE:
1086{ 1394{
1087 STRLEN textlen; 1395 STRLEN textlen;
1088 char *text = SvPVutf8 (text_, textlen); 1396 char *text = SvPVutf8 (text_, textlen);
1089 1397
1090 pango_layout_set_markup (self->pl, text, textlen); 1398 pango_layout_set_markup (self->pl, text, textlen);
1091} 1399}
1092 1400
1093void 1401void
1094set_shapes (CFPlus::Layout self, ...) 1402set_shapes (DC::Layout self, ...)
1095 CODE: 1403 CODE:
1096{ 1404{
1097 PangoAttrList *attrs = 0; 1405 PangoAttrList *attrs = 0;
1098 const char *text = pango_layout_get_text (self->pl); 1406 const char *text = pango_layout_get_text (self->pl);
1099 const char *pos = text; 1407 const char *pos = text;
… …
1134 if (attrs) 1442 if (attrs)
1135 pango_layout_set_attributes (self->pl, attrs); 1443 pango_layout_set_attributes (self->pl, attrs);
1136} 1444}
1137 1445
1138void 1446void
1139get_shapes (CFPlus::Layout self) 1447get_shapes (DC::Layout self)
1140 PPCODE: 1448 PPCODE:
1141{ 1449{
1142 PangoLayoutIter *iter = pango_layout_get_iter (self->pl); 1450 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1143 1451
1144 do 1452 do
1145 { 1453 {
1146 PangoLayoutRun *run = pango_layout_iter_get_run (iter); 1454 PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
1147 1455
1148 if (run && shape_attr_p (run)) 1456 if (run && shape_attr_p (run))
1149 { 1457 {
1150 PangoRectangle extents; 1458 PangoRectangle extents;
1151 pango_layout_iter_get_run_extents (iter, 0, &extents); 1459 pango_layout_iter_get_run_extents (iter, 0, &extents);
… …
1159 1467
1160 pango_layout_iter_free (iter); 1468 pango_layout_iter_free (iter);
1161} 1469}
1162 1470
1163int 1471int
1164has_wrapped (CFPlus::Layout self) 1472has_wrapped (DC::Layout self)
1165 CODE: 1473 CODE:
1166{ 1474{
1167 int lines = 1; 1475 int lines = 1;
1168 const char *text = pango_layout_get_text (self->pl); 1476 const char *text = pango_layout_get_text (self->pl);
1169 1477
… …
1174} 1482}
1175 OUTPUT: 1483 OUTPUT:
1176 RETVAL 1484 RETVAL
1177 1485
1178SV * 1486SV *
1179get_text (CFPlus::Layout self) 1487get_text (DC::Layout self)
1180 CODE: 1488 CODE:
1181 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0); 1489 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1182 sv_utf8_decode (RETVAL); 1490 sv_utf8_decode (RETVAL);
1183 OUTPUT: 1491 OUTPUT:
1184 RETVAL 1492 RETVAL
1185 1493
1186void 1494void
1187set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.) 1495set_foreground (DC::Layout self, float r, float g, float b, float a = 1.)
1188 CODE: 1496 CODE:
1189 self->r = r; 1497 self->r = r;
1190 self->g = g; 1498 self->g = g;
1191 self->b = b; 1499 self->b = b;
1192 self->a = a; 1500 self->a = a;
1193 1501
1194void 1502void
1195set_font (CFPlus::Layout self, CFPlus::Font font = 0) 1503set_font (DC::Layout self, DC::Font font = 0)
1196 CODE: 1504 CODE:
1197 if (self->font != font) 1505 if (self->font != font)
1198 { 1506 {
1199 self->font = font; 1507 self->font = font;
1200 layout_update_font (self); 1508 layout_update_font (self);
1201 } 1509 }
1202 1510
1203void 1511void
1204set_height (CFPlus::Layout self, int base_height) 1512set_height (DC::Layout self, int base_height)
1205 CODE: 1513 CODE:
1206 if (self->base_height != base_height) 1514 if (self->base_height != base_height)
1207 { 1515 {
1208 self->base_height = base_height; 1516 self->base_height = base_height;
1209 layout_update_font (self); 1517 layout_update_font (self);
1210 } 1518 }
1211 1519
1212void 1520void
1213set_width (CFPlus::Layout self, int max_width = -1) 1521set_width (DC::Layout self, int max_width = -1)
1214 CODE: 1522 CODE:
1215 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1523 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
1216 1524
1217void 1525void
1218set_indent (CFPlus::Layout self, int indent) 1526set_indent (DC::Layout self, int indent)
1219 CODE: 1527 CODE:
1220 pango_layout_set_indent (self->pl, indent * PANGO_SCALE); 1528 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1221 1529
1222void 1530void
1223set_spacing (CFPlus::Layout self, int spacing) 1531set_spacing (DC::Layout self, int spacing)
1224 CODE: 1532 CODE:
1225 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE); 1533 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1226 1534
1227void 1535void
1228set_ellipsise (CFPlus::Layout self, int ellipsise) 1536set_ellipsise (DC::Layout self, int ellipsise)
1229 CODE: 1537 CODE:
1230 pango_layout_set_ellipsize (self->pl, 1538 pango_layout_set_ellipsize (self->pl,
1231 ellipsise == 1 ? PANGO_ELLIPSIZE_START 1539 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1232 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE 1540 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1233 : ellipsise == 3 ? PANGO_ELLIPSIZE_END 1541 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1234 : PANGO_ELLIPSIZE_NONE 1542 : PANGO_ELLIPSIZE_NONE
1235 ); 1543 );
1236 1544
1237void 1545void
1238set_single_paragraph_mode (CFPlus::Layout self, int spm) 1546set_single_paragraph_mode (DC::Layout self, int spm)
1239 CODE: 1547 CODE:
1240 pango_layout_set_single_paragraph_mode (self->pl, !!spm); 1548 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1241 1549
1242void 1550void
1243size (CFPlus::Layout self) 1551size (DC::Layout self)
1244 PPCODE: 1552 PPCODE:
1245{ 1553{
1246 int w, h; 1554 int w, h;
1247 1555
1248 layout_get_pixel_size (self, &w, &h); 1556 layout_get_pixel_size (self, &w, &h);
… …
1251 PUSHs (sv_2mortal (newSViv (w))); 1559 PUSHs (sv_2mortal (newSViv (w)));
1252 PUSHs (sv_2mortal (newSViv (h))); 1560 PUSHs (sv_2mortal (newSViv (h)));
1253} 1561}
1254 1562
1255int 1563int
1256descent (CFPlus::Layout self) 1564descent (DC::Layout self)
1257 CODE: 1565 CODE:
1258{ 1566{
1259 PangoRectangle rect; 1567 PangoRectangle rect;
1260 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0); 1568 PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1261 pango_layout_line_get_pixel_extents (line, 0, &rect); 1569 pango_layout_line_get_pixel_extents (line, 0, &rect);
1262 RETVAL = PANGO_DESCENT (rect); 1570 RETVAL = PANGO_DESCENT (rect);
1263} 1571}
1264 OUTPUT: 1572 OUTPUT:
1265 RETVAL 1573 RETVAL
1266 1574
1267int 1575int
1268xy_to_index (CFPlus::Layout self, int x, int y) 1576xy_to_index (DC::Layout self, int x, int y)
1269 CODE: 1577 CODE:
1270{ 1578{
1271 int index, trailing; 1579 int index, trailing;
1272 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1580 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1273 RETVAL = index + trailing; 1581 RETVAL = index + trailing;
1274} 1582}
1275 OUTPUT: 1583 OUTPUT:
1276 RETVAL 1584 RETVAL
1277 1585
1278void 1586void
1279cursor_pos (CFPlus::Layout self, int index) 1587cursor_pos (DC::Layout self, int index)
1280 PPCODE: 1588 PPCODE:
1281{ 1589{
1282 PangoRectangle strong_pos; 1590 PangoRectangle pos;
1283 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1591 pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1284 1592
1285 EXTEND (SP, 3); 1593 EXTEND (SP, 3);
1286 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1594 PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1287 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1595 PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1288 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1596 PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1289} 1597}
1290 1598
1291void 1599void
1292index_to_line_x (CFPlus::Layout self, int index, int trailing = 0) 1600index_to_line_x (DC::Layout self, int index, int trailing = 0)
1293 PPCODE: 1601 PPCODE:
1294{ 1602{
1295 int line, x; 1603 int line, x;
1296 1604
1297 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x); 1605 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1606#if !PANGO_VERSION_CHECK (1, 17, 3)
1298 /* pango bug: line is between 1..numlines, not 0..numlines-1 */ 1607 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1299 1608 --line;
1609#endif
1300 EXTEND (SP, 2); 1610 EXTEND (SP, 2);
1301 PUSHs (sv_2mortal (newSViv (line - 1))); 1611 PUSHs (sv_2mortal (newSViv (line)));
1302 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE))); 1612 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1303} 1613}
1304 1614
1305void 1615void
1306line_x_to_index (CFPlus::Layout self, int line, int x) 1616line_x_to_index (DC::Layout self, int line, int x)
1307 PPCODE: 1617 PPCODE:
1308{ 1618{
1309 PangoLayoutLine *lp; 1619 PangoLayoutLine *lp;
1310 int index, trailing; 1620 int index, trailing;
1311 1621
1312 if (line < 0) 1622 if (line < 0)
1313 XSRETURN_EMPTY; 1623 XSRETURN_EMPTY;
1314 1624
1315 if (!(lp = pango_layout_get_line (self->pl, line))) 1625 if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1316 XSRETURN_EMPTY; /* do better */ 1626 XSRETURN_EMPTY; /* do better */
1317 1627
1318 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing); 1628 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1319 1629
1320 EXTEND (SP, 2); 1630 EXTEND (SP, 2);
… …
1326 PUSHs (sv_2mortal (newSViv (trailing))); 1636 PUSHs (sv_2mortal (newSViv (trailing)));
1327 } 1637 }
1328} 1638}
1329 1639
1330void 1640void
1331render (CFPlus::Layout self, float x, float y, int flags = 0) 1641render (DC::Layout self, float x, float y, int flags = 0)
1332 CODE: 1642 CODE:
1333 rc_clear (self->rc); 1643 self->rc.clear ();
1334 pango_opengl_render_layout_subpixel ( 1644 pango_opengl_render_layout_subpixel (
1335 self->pl, 1645 self->pl,
1336 self->rc, 1646 &self->rc,
1337 x * PANGO_SCALE, y * PANGO_SCALE, 1647 x * PANGO_SCALE, y * PANGO_SCALE,
1338 self->r, self->g, self->b, self->a, 1648 self->r, self->g, self->b, self->a,
1339 flags 1649 flags
1340 ); 1650 );
1341 // we assume that context_change actually clears/frees stuff 1651 // we assume that context_change actually clears/frees stuff
1342 // and does not do any recomputation... 1652 // and does not do any recomputation...
1343 pango_layout_context_changed (self->pl); 1653 pango_layout_context_changed (self->pl);
1344 1654
1345void 1655void
1346draw (CFPlus::Layout self) 1656draw (DC::Layout self)
1347 CODE: 1657 CODE:
1348{ 1658{
1349 glEnable (GL_TEXTURE_2D); 1659 glEnable (GL_TEXTURE_2D);
1350 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 1660 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1351 glEnable (GL_BLEND); 1661 glEnable (GL_BLEND);
1352 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, 1662 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1353 GL_ONE , GL_ONE_MINUS_SRC_ALPHA); 1663 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1354 glEnable (GL_ALPHA_TEST); 1664 glEnable (GL_ALPHA_TEST);
1355 glAlphaFunc (GL_GREATER, 7.f / 255.f); 1665 glAlphaFunc (GL_GREATER, 7.f / 255.f);
1356 1666
1357 rc_draw (self->rc); 1667 self->rc.draw ();
1358 1668
1359 glDisable (GL_ALPHA_TEST); 1669 glDisable (GL_ALPHA_TEST);
1360 glDisable (GL_BLEND); 1670 glDisable (GL_BLEND);
1361 glDisable (GL_TEXTURE_2D); 1671 glDisable (GL_TEXTURE_2D);
1362} 1672}
1363 1673
1364MODULE = CFPlus PACKAGE = CFPlus::Texture 1674MODULE = Deliantra::Client PACKAGE = DC::Texture
1365 1675
1366PROTOTYPES: ENABLE 1676PROTOTYPES: ENABLE
1367 1677
1368void 1678void
1369pad (SV *data_, int ow, int oh, int nw, int nh) 1679pad (SV *data_, int ow, int oh, int nw, int nh)
… …
1437 glDisable (GL_ALPHA_TEST); 1747 glDisable (GL_ALPHA_TEST);
1438 glDisable (GL_BLEND); 1748 glDisable (GL_BLEND);
1439 } 1749 }
1440} 1750}
1441 1751
1752void
1753draw_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)
1754 PROTOTYPE: @
1755 CODE:
1756{
1757 glEnable (GL_BLEND);
1758 glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1759 glEnable (GL_TEXTURE_2D);
1760 glBindTexture (GL_TEXTURE_2D, name1);
1761
1762 glColor3f (intensity, intensity, intensity);
1763 glPushMatrix ();
1764 glScalef (1./3, 1./3, 1.);
1765
1766 if (blend > 0.f)
1767 {
1768 float dx3 = dx * -3.f / w;
1769 float dy3 = dy * -3.f / h;
1770 GLfloat env_color[4] = { 0., 0., 0., blend };
1771
1772 /* interpolate the two shadow textures */
1773 /* stage 0 == rgb(glcolor) + alpha(t0) */
1774 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1775
1776 /* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
1777 gl.ActiveTexture (GL_TEXTURE1);
1778 glEnable (GL_TEXTURE_2D);
1779 glBindTexture (GL_TEXTURE_2D, name2);
1780 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
1781
1782 /* rgb == rgb(glcolor) */
1783 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
1784 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
1785 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
1786
1787 /* alpha = interpolate t0, t1 by env_alpha */
1788 glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
1789
1790 glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
1791 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
1792 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
1793
1794 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
1795 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
1796
1797 glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
1798 glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
1799
1800 glBegin (GL_QUADS);
1801 gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
1802 gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
1803 gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
1804 gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
1805 glEnd ();
1806
1807 glDisable (GL_TEXTURE_2D);
1808 gl.ActiveTexture (GL_TEXTURE0);
1809 }
1810 else
1811 {
1812 /* simple blending of one texture, also opengl <1.3 path */
1813 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1814
1815 glBegin (GL_QUADS);
1816 glTexCoord2f (0, 0); glVertex2f (0, 0);
1817 glTexCoord2f (0, t); glVertex2f (0, h);
1818 glTexCoord2f (s, t); glVertex2f (w, h);
1819 glTexCoord2f (s, 0); glVertex2f (w, 0);
1820 glEnd ();
1821 }
1822
1823 /* draw ?-marks or equivalent, this is very clumsy code :/ */
1824 {
1825 int x, y;
1826 int dx3 = dx * 3;
1827 int dy3 = dy * 3;
1828
1829 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1830 glBindTexture (GL_TEXTURE_2D, hidden_tex);
1831 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1832 glTranslatef (-1., -1., 0);
1833 glBegin (GL_QUADS);
1834
1835 for (y = 1; y < h; y += 3)
1836 {
1837 int y1 = y - dy3;
1838 int y1valid = y1 >= 0 && y1 < h;
1839
1840 for (x = 1; x < w; x += 3)
1841 {
1842 int x1 = x - dx3;
1843 uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1844 uint8_t h2;
1845
1846 if (y1valid && x1 >= 0 && x1 < w)
1847 h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
1848 else
1849 h2 = 1; /* out of range == invisible */
1850
1851 if (h1 || h2)
1852 {
1853 float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
1854 glColor4f (1., 1., 1., alpha);
1855
1856 glTexCoord2f (0, 0.); glVertex2i (x , y );
1857 glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
1858 glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
1859 glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
1860 }
1861 }
1862 }
1863 }
1864
1865 glEnd ();
1866
1867 glPopMatrix ();
1868
1869 glDisable (GL_TEXTURE_2D);
1870 glDisable (GL_BLEND);
1871}
1872
1442IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type) 1873IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1443 CODE: 1874 CODE:
1444{ 1875{
1445 GLint width; 1876 GLint width;
1446 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0); 1877 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
… …
1448 RETVAL = width > 0; 1879 RETVAL = width > 0;
1449} 1880}
1450 OUTPUT: 1881 OUTPUT:
1451 RETVAL 1882 RETVAL
1452 1883
1453MODULE = CFPlus PACKAGE = CFPlus::Map 1884MODULE = Deliantra::Client PACKAGE = DC::Map
1454 1885
1455PROTOTYPES: DISABLE 1886PROTOTYPES: DISABLE
1456 1887
1457CFPlus::Map 1888DC::Map
1458new (SV *class) 1889new (SV *klass)
1459 CODE: 1890 CODE:
1460 New (0, RETVAL, 1, struct map); 1891 RETVAL = new mapgrid;
1461 RETVAL->x = 0; 1892 RETVAL->x = 0;
1462 RETVAL->y = 0; 1893 RETVAL->y = 0;
1463 RETVAL->w = 0; 1894 RETVAL->w = 0;
1464 RETVAL->h = 0; 1895 RETVAL->h = 0;
1465 RETVAL->ox = 0; 1896 RETVAL->ox = 0;
1466 RETVAL->oy = 0; 1897 RETVAL->oy = 0;
1467 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1468 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
1469 RETVAL->rows = 0; 1898 RETVAL->rows = 0;
1470 RETVAL->row = 0; 1899 RETVAL->row = 0;
1471 OUTPUT: 1900 OUTPUT:
1472 RETVAL 1901 RETVAL
1473 1902
1474void 1903void
1475DESTROY (CFPlus::Map self) 1904DESTROY (DC::Map self)
1476 CODE: 1905 CODE:
1477{ 1906{
1478 map_clear (self);
1479 Safefree (self->face2tile);
1480 Safefree (self->tex);
1481 Safefree (self); 1907 delete self;
1482} 1908}
1483 1909
1484void 1910void
1485resize (CFPlus::Map self, int map_width, int map_height) 1911resize (DC::Map self, int map_width, int map_height)
1486 CODE: 1912 CODE:
1487 self->w = map_width; 1913 self->w = map_width;
1488 self->h = map_height; 1914 self->h = map_height;
1489 1915
1490void 1916void
1491clear (CFPlus::Map self) 1917clear (DC::Map self)
1492 CODE: 1918 CODE:
1493 map_clear (self); 1919 self->clear_cells ();
1494 1920
1495void 1921void
1496set_tileid (CFPlus::Map self, int face, int tile) 1922set_tileid (DC::Map self, int face, int tile)
1497 CODE: 1923 CODE:
1498{ 1924{
1499 need_facenum (self, face); self->face2tile [face] = tile; 1925 if (self->tile.size () <= face) self->tile.resize (face + 1);
1500 need_texid (self, tile); 1926 self->tile[face] = tile;
1927 if (self->tex.size () <= tile) self->tex .resize (tile + 1);
1501} 1928}
1502 1929
1503void 1930void
1504set_smooth (CFPlus::Map self, int face, int smooth, int level) 1931set_smooth (DC::Map self, int face, int smooth, int level)
1505 CODE: 1932 CODE:
1506{ 1933{
1507 tileid texid;
1508 maptex *tex;
1509
1510 if (face < 0 || face >= self->faces) 1934 if (face < 0 || face >= self->tile.size ())
1511 return; 1935 return;
1512 1936
1513 if (smooth < 0 || smooth >= self->faces) 1937 if (smooth < 0 || smooth >= self->tile.size ())
1514 return; 1938 return;
1515 1939
1516 texid = self->face2tile [face]; 1940 tileid texid = self->tile[face];
1517 1941
1518 if (!texid) 1942 if (!texid)
1519 return; 1943 return;
1520 1944
1521 tex = self->tex + texid; 1945 maptex &tex = self->tex[texid];
1522 tex->smoothtile = self->face2tile [smooth]; 1946 tex.smoothtile = self->tile[smooth];
1523 tex->smoothlevel = level; 1947 tex.smoothlevel = level;
1524} 1948}
1525 1949
1526void 1950void
1527set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1951set_texture (DC::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1528 CODE: 1952 CODE:
1529{ 1953{
1530 need_texid (self, texid); 1954 if (self->tex.size () < texid) self->tex.resize (texid + 1);
1531 1955
1532 { 1956 {
1533 maptex *tex = self->tex + texid; 1957 maptex &tex = self->tex[texid];
1534 1958
1535 tex->name = name; 1959 tex.name = name;
1536 tex->w = w; 1960 tex.w = w;
1537 tex->h = h; 1961 tex.h = h;
1538 tex->s = s; 1962 tex.s = s;
1539 tex->t = t; 1963 tex.t = t;
1540 tex->r = r; 1964 tex.r = r;
1541 tex->g = g; 1965 tex.g = g;
1542 tex->b = b; 1966 tex.b = b;
1543 tex->a = a; 1967 tex.a = a;
1544 } 1968 }
1545 1969
1546 // somewhat hackish, but for textures that require it, it really 1970 // somewhat hackish, but for textures that require it, it really
1547 // improves the look, and most others don't suffer. 1971 // improves the look, and most others don't suffer.
1548 glBindTexture (GL_TEXTURE_2D, name); 1972 glBindTexture (GL_TEXTURE_2D, name);
… …
1551 // use uglier nearest interpolation because linear suffers 1975 // use uglier nearest interpolation because linear suffers
1552 // from transparent color bleeding and ugly wrapping effects. 1976 // from transparent color bleeding and ugly wrapping effects.
1553 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1977 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1554} 1978}
1555 1979
1980void
1981expire_textures (DC::Map self, int texid, int count)
1982 PPCODE:
1983 for (; texid < self->tex.size () && count; ++texid, --count)
1984 {
1985 maptex &tex = self->tex[texid];
1986
1987 if (tex.name)
1988 {
1989 if (tex.unused)
1990 {
1991 tex.name = 0;
1992 tex.unused = 0;
1993 XPUSHs (sv_2mortal (newSViv (texid)));
1994 }
1995 else
1996 tex.unused = 1;
1997 }
1998 }
1999
1556int 2000int
1557ox (CFPlus::Map self) 2001ox (DC::Map self)
1558 ALIAS: 2002 ALIAS:
1559 oy = 1 2003 oy = 1
1560 x = 2 2004 x = 2
1561 y = 3 2005 y = 3
1562 w = 4 2006 w = 4
… …
1573 } 2017 }
1574 OUTPUT: 2018 OUTPUT:
1575 RETVAL 2019 RETVAL
1576 2020
1577void 2021void
1578scroll (CFPlus::Map self, int dx, int dy) 2022scroll (DC::Map self, int dx, int dy)
1579 CODE: 2023 CODE:
1580{ 2024{
1581 if (dx > 0) 2025 if (dx > 0)
1582 map_blank (self, self->x, self->y, dx, self->h); 2026 map_blank (self, self->x, self->y, dx, self->h);
1583 else if (dx < 0) 2027 else if (dx < 0)
… …
1599 self->y += MAP_EXTEND_Y; 2043 self->y += MAP_EXTEND_Y;
1600 } 2044 }
1601} 2045}
1602 2046
1603SV * 2047SV *
1604map1a_update (CFPlus::Map self, SV *data_, int extmap) 2048map1a_update (DC::Map self, SV *data_)
1605 CODE: 2049 CODE:
1606{ 2050{
1607 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2051 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1608 uint8_t *data_end = (uint8_t *)SvEND (data_); 2052 uint8_t *data_end = (uint8_t *)SvEND (data_);
1609 mapcell *cell; 2053 mapcell *cell;
… …
1630 2074
1631 //TODO: don't trust server data to be in-range(!) 2075 //TODO: don't trust server data to be in-range(!)
1632 2076
1633 if (flags & 8) 2077 if (flags & 8)
1634 { 2078 {
2079 uint8_t ext, cmd;
2080
1635 if (extmap) 2081 do
1636 { 2082 {
1637 uint8_t ext, cmd; 2083 ext = *data++;
2084 cmd = ext & 0x7f;
1638 2085
1639 do 2086 if (cmd < 4)
2087 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
2088 else if (cmd == 5) // health
1640 { 2089 {
1641 ext = *data++;
1642 cmd = ext & 0x3f;
1643
1644 if (cmd < 4)
1645 cell->darkness = 255 - ext * 64 + 1;
1646 else if (cmd == 5) // health
1647 {
1648 cell->stat_width = 1; 2090 cell->stat_width = 1;
1649 cell->stat_hp = *data++; 2091 cell->stat_hp = *data++;
1650 }
1651 else if (cmd == 6) // monster width
1652 cell->stat_width = *data++ + 1;
1653 else if (cmd == 0x47)
1654 {
1655 if (*data == 4)
1656 ; // decode player count
1657
1658 data += *data + 1;
1659 }
1660 else if (cmd == 8) // cell flags
1661 cell->flags = *data++;
1662 else if (ext & 0x40) // unknown, multibyte => skip
1663 data += *data + 1;
1664 else
1665 data++;
1666 } 2092 }
1667 while (ext & 0x80); 2093 else if (cmd == 6) // monster width
2094 cell->stat_width = *data++ + 1;
2095 else if (cmd == 0x47)
2096 {
2097 if (*data == 1) cell->player = data [1];
2098 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2099 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2100 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
2101
2102 data += *data + 1;
2103 }
2104 else if (cmd == 8) // cell flags
2105 cell->flags = *data++;
2106 else if (ext & 0x40) // unknown, multibyte => skip
2107 data += *data + 1;
2108 else
2109 data++;
1668 } 2110 }
1669 else 2111 while (ext & 0x80);
1670 cell->darkness = *data++ + 1;
1671 } 2112 }
1672 2113
1673 for (z = 0; z <= 2; ++z) 2114 for (z = 0; z <= 2; ++z)
1674 if (flags & (4 >> z)) 2115 if (flags & (4 >> z))
1675 { 2116 {
1676 faceid face = (data [0] << 8) + data [1]; data += 2; 2117 faceid face = (data[0] << 8) + data[1]; data += 2;
1677 need_facenum (self, face); 2118 if (self->tile.size () <= face) self->tile.resize (face + 1);
1678 cell->tile [z] = self->face2tile [face]; 2119 cell->tile[z] = self->tile[face];
1679 2120
1680 if (cell->tile [z]) 2121 if (cell->tile[z])
1681 { 2122 {
1682 maptex *tex = self->tex + cell->tile [z]; 2123 maptex &tex = self->tex[cell->tile[z]];
2124 tex.unused = 0;
1683 if (!tex->name) 2125 if (!tex.name)
1684 av_push (missing, newSViv (cell->tile [z])); 2126 av_push (missing, newSViv (cell->tile [z]));
1685 2127
1686 if (tex->smoothtile) 2128 if (tex.smoothtile)
1687 { 2129 {
1688 maptex *smooth = self->tex + tex->smoothtile; 2130 maptex &smooth = self->tex[tex.smoothtile];
2131 smooth.unused = 0;
1689 if (!smooth->name) 2132 if (!smooth.name)
1690 av_push (missing, newSViv (tex->smoothtile)); 2133 av_push (missing, newSViv (tex.smoothtile));
1691 } 2134 }
1692 } 2135 }
1693 } 2136 }
1694 } 2137 }
1695 else 2138 else
1696 cell->darkness = 0; 2139 CELL_CLEAR (cell);
1697 } 2140 }
1698} 2141}
1699 OUTPUT: 2142 OUTPUT:
1700 RETVAL 2143 RETVAL
1701 2144
1702SV * 2145SV *
1703mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 2146mapmap (DC::Map self, int x0, int y0, int w, int h)
1704 CODE: 2147 CODE:
1705{ 2148{
1706 int x1, x; 2149 int x1, x;
1707 int y1, y; 2150 int y1, y;
1708 int z; 2151 int z;
… …
1721 ? self->row + y 2164 ? self->row + y
1722 : 0; 2165 : 0;
1723 2166
1724 for (x = x0; x < x1; x++) 2167 for (x = x0; x < x1; x++)
1725 { 2168 {
1726 int r = 32, g = 32, b = 32, a = 192; 2169 unsigned int r = 32, g = 32, b = 32, a = 192;
1727 2170
1728 if (row && row->c0 <= x && x < row->c1) 2171 if (row && row->c0 <= x && x < row->c1)
1729 { 2172 {
1730 mapcell *cell = row->col + (x - row->c0); 2173 mapcell *cell = row->col + (x - row->c0);
1731 2174
… …
1733 { 2176 {
1734 maptex tex = self->tex [cell->tile [z]]; 2177 maptex tex = self->tex [cell->tile [z]];
1735 int a0 = 255 - tex.a; 2178 int a0 = 255 - tex.a;
1736 int a1 = tex.a; 2179 int a1 = tex.a;
1737 2180
1738 r = (r * a0 + tex.r * a1) / 255; 2181 r = div255 (r * a0 + tex.r * a1);
1739 g = (g * a0 + tex.g * a1) / 255; 2182 g = div255 (g * a0 + tex.g * a1);
1740 b = (b * a0 + tex.b * a1) / 255; 2183 b = div255 (b * a0 + tex.b * a1);
1741 a = (a * a0 + tex.a * a1) / 255; 2184 a = div255 (a * a0 + tex.a * a1);
1742 } 2185 }
1743 } 2186 }
1744 2187
1745 *map++ = (r ) 2188 *map++ = (r )
1746 | (g << 8) 2189 | (g << 8)
1747 | (b << 16) 2190 | (b << 16)
1748 | (a << 24); 2191 | (a << 24);
1749 } 2192 }
1750 } 2193 }
1751 2194
1752 RETVAL = map_sv; 2195 RETVAL = map_sv;
1753} 2196}
1754 OUTPUT: 2197 OUTPUT:
1755 RETVAL 2198 RETVAL
1756 2199
1757void 2200void
1758draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T) 2201draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1759 CODE: 2202 CODE:
1760{ 2203{
1761 int x, y, z; 2204 int x, y, z;
1762 2205
1763 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1764 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1765 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2206 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
1766 smooth_key skey; 2207 int pl_x, pl_y;
1767 2208 maptex pl_tex;
1768 rc_t *rc = rc_alloc (); 2209 rc_t rc;
2210 rc_t rc_ov;
1769 rc_key_t key; 2211 rc_key_t key;
1770 rc_array_t *arr; 2212 rc_t::array_t *arr;
1771 2213
2214 pl_tex.name = 0;
2215
1772 // thats current max. sorry. 2216 // that's current max. sorry.
1773 if (sw > 255) sw = 255; 2217 if (sw > 255) sw = 255;
1774 if (sh > 255) sh = 255; 2218 if (sh > 255) sh = 255;
1775
1776 // clear key, in case of extra padding
1777 memset (&skey, 0, sizeof (skey));
1778 2219
1779 memset (&key, 0, sizeof (key)); 2220 memset (&key, 0, sizeof (key));
1780 key.r = 255; 2221 key.r = 255;
1781 key.g = 255; 2222 key.g = 255;
1782 key.b = 255; 2223 key.b = 255;
1783 key.a = 255; 2224 key.a = 255;
1784 key.mode = GL_QUADS; 2225 key.mode = GL_QUADS;
1785 key.format = GL_T2F_V3F; 2226 key.format = GL_T2F_V3F;
1786 key.texname = -1;
1787 2227
1788 mx += self->x; 2228 mx += self->x;
1789 my += self->y; 2229 my += self->y;
1790 2230
1791 // first pass: determine smooth_max 2231 // first pass: determine smooth_max
1792 // rather ugly, if you ask me 2232 // rather ugly, if you ask me
1793 // could also be stored inside mapcell and updated on change 2233 // could also be stored inside mapcell and updated on change
1794 memset (smooth_max, 0, sizeof (smooth_max)); 2234 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1795 2235
1796 for (y = 0; y < sh; y++) 2236 for (y = 0; y < sh; y++)
1797 if (0 <= y + my && y + my < self->rows) 2237 if (0 <= y + my && y + my < self->rows)
1798 { 2238 {
1799 maprow *row = self->row + (y + my); 2239 maprow *row = self->row + (y + my);
… …
1814 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2254 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1815 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2255 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1816 2256
1817 for (z = 0; z <= 2; z++) 2257 for (z = 0; z <= 2; z++)
1818 { 2258 {
1819 memset (smooth_level, 0, sizeof (smooth_level)); 2259 std::bitset<256> smooth_level; // one bit for every possible smooth level
2260 smooth_key skey;
2261 smooth_hash smooth;
2262 key.texname = -1;
1820 2263
1821 for (y = 0; y < sh; y++) 2264 for (y = 0; y < sh; y++)
1822 if (0 <= y + my && y + my < self->rows) 2265 if (0 <= y + my && y + my < self->rows)
1823 { 2266 {
1824 maprow *row = self->row + (y + my); 2267 maprow *row = self->row + (y + my);
… …
1834 maptex tex = self->tex [tile]; 2277 maptex tex = self->tex [tile];
1835 int px, py; 2278 int px, py;
1836 2279
1837 if (key.texname != tex.name) 2280 if (key.texname != tex.name)
1838 { 2281 {
2282 self->tex [tile].unused = 0;
2283
1839 if (!tex.name) 2284 if (!tex.name)
1840 tex = self->tex [2]; /* missing, replace by noface */ 2285 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1841 2286
1842 key.texname = tex.name; 2287 key.texname = tex.name;
1843 arr = rc_array (rc, &key); 2288 arr = &rc.array (key);
1844 } 2289 }
1845 2290
1846 px = (x + 1) * T - tex.w; 2291 px = (x + 1) * Th - tex.w;
1847 py = (y + 1) * T - tex.h; 2292 py = (y + 1) * Tw - tex.h;
1848 2293
1849 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2294 if (expect_false (cell->player == player) && expect_false (z == 2))
1850 rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1851 rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1852 rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1853
1854 if (cell->flags && z == 2)
1855 { 2295 {
1856 // overlays such as the speech bubble, probably more to come 2296 pl_x = px;
1857 if (cell->flags & 1) 2297 pl_y = py;
2298 pl_tex = tex;
1858 { 2299 continue;
1859 maptex tex = self->tex [1];
1860 int px = x * T + T * 2 / 32;
1861 int py = y * T - T * 6 / 32;
1862
1863 if (tex.name)
1864 {
1865 if (key.texname != tex.name)
1866 {
1867 key.texname = tex.name;
1868 arr = rc_array (rc, &key);
1869 }
1870
1871 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1872 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1873 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1874 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1875 }
1876 }
1877 } 2300 }
2301
2302 arr->t2f_v3f (0 , 0 , px , py , 0);
2303 arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2304 arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2305 arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
1878 2306
1879 // update smooth hash 2307 // update smooth hash
1880 if (tex.smoothtile) 2308 if (tex.smoothtile)
1881 { 2309 {
1882 skey.tile = tex.smoothtile; 2310 skey.tile = tex.smoothtile;
1883 skey.level = tex.smoothlevel; 2311 skey.level = tex.smoothlevel;
1884 2312
1885 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31); 2313 smooth_level[tex.smoothlevel] = 1;
1886 2314
1887 // add bits to current tile and all neighbours. skey.x|y is 2315 // add bits to current tile and all neighbours. skey.x|y is
1888 // shifted +1|+1 so we always stay positive. 2316 // shifted +1|+1 so we always stay positive.
1889 2317
1890 // bits is ___n cccc CCCC bbbb 2318 // bits is ___n cccc CCCC bbbb
… …
1898 2326
1899 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2327 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1900 // ·· ·· ·┏ ┓· 2328 // ·· ·· ·┏ ┓·
1901 2329
1902 // full tile 2330 // full tile
1903 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 2331 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
1904 2332
1905 // borders 2333 // borders
1906 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091); 2334 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
1907 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032); 2335 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
1908 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 2336 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
1909 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 2337 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
1910 2338
1911 // corners 2339 // corners
1912 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2340 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
1913 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2341 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
1914 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2342 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
1915 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2343 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
2344 }
2345 }
2346
2347 if (expect_false (z == 2) && expect_false (cell->flags))
2348 {
2349 // overlays such as the speech bubble, probably more to come
2350 if (cell->flags & 1)
2351 {
2352 rc_key_t key_ov = key;
2353 maptex tex = self->tex[TEXID_SPEECH];
2354 int px = x * Tw + Tw * 2 / 32;
2355 int py = y * Th - Th * 6 / 32;
2356
2357 key_ov.texname = tex.name;
2358 rc_t::array_t &arr = rc_ov.array (key_ov);
2359
2360 arr.t2f_v3f (0 , 0 , px , py , 0);
2361 arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
2362 arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
2363 arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
1916 } 2364 }
1917 } 2365 }
1918 } 2366 }
1919 } 2367 }
1920 2368
1921 rc_draw (rc); 2369 rc.draw ();
1922 rc_clear (rc); 2370 rc.clear ();
1923 2371
1924 // go through all smoothlevels, lowest to highest, then draw. 2372 // go through all smoothlevels, lowest to highest, then draw.
1925 // this is basically counting sort 2373 // this is basically counting sort
1926 { 2374 {
1927 int w, b; 2375 int w, b;
1928 2376
1929 glEnable (GL_TEXTURE_2D); 2377 glEnable (GL_TEXTURE_2D);
1930 glBegin (GL_QUADS); 2378 glBegin (GL_QUADS);
1931 for (w = 0; w < 256 / 32; ++w) 2379 for (int level = 0; level < smooth_level.size (); ++level)
2380 if (smooth_level[level])
2381 for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
1932 { 2382 {
1933 uint32_t smask = smooth_level [w]; 2383 smooth_key &skey = it->first;
1934 if (smask) 2384 IV bits = it->second;
1935 for (b = 0; b < 32; ++b) 2385
1936 if (smask & (((uint32_t)1) << b)) 2386 if (!(bits & 0x1000)
2387 && skey.level == level
2388 && level > smooth_max [skey.x][skey.y])
1937 { 2389 {
1938 int level = (w << 5) | b; 2390 maptex tex = self->tex [skey.tile];
2391 int px = (((int)skey.x) - 1) * Tw;
2392 int py = (((int)skey.y) - 1) * Th;
2393 int border = bits & 15;
2394 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2395 float dx = tex.s * .0625f; // 16 images/row
2396 float dy = tex.t * .5f ; // 2 images/column
2397
1939 HE *he; 2398 if (tex.name)
1940
1941 hv_iterinit (smooth);
1942 while ((he = hv_iternext (smooth)))
1943 { 2399 {
1944 smooth_key *skey = (smooth_key *)HeKEY (he); 2400 // this time avoiding texture state changes
1945 IV bits = SvIVX (HeVAL (he)); 2401 // save gobs of state changes.
1946 2402 if (key.texname != tex.name)
1947 if (!(bits & 0x1000)
1948 && skey->level == level
1949 && level > smooth_max [skey->x][skey->y])
1950 { 2403 {
1951 maptex tex = self->tex [skey->tile]; 2404 self->tex [skey.tile].unused = 0;
1952 int px = (((int)skey->x) - 1) * T;
1953 int py = (((int)skey->y) - 1) * T;
1954 int border = bits & 15;
1955 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1956 float dx = tex.s * .0625f; // 16 images/row
1957 float dy = tex.t * .5f ; // 2 images/column
1958 2405
1959 if (tex.name)
1960 {
1961 // this time avoiding texture state changes
1962 // save gobs of state changes.
1963 if (key.texname != tex.name)
1964 {
1965 glEnd (); 2406 glEnd ();
1966 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2407 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1967 glBegin (GL_QUADS); 2408 glBegin (GL_QUADS);
1968 } 2409 }
1969 2410
1970 if (border) 2411 if (border)
1971 { 2412 {
1972 float ox = border * dx; 2413 float ox = border * dx;
1973 2414
1974 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2415 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1975 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2416 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
1976 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2417 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
1977 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2418 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
1978 } 2419 }
1979 2420
1980 if (corner) 2421 if (corner)
1981 { 2422 {
1982 float ox = corner * dx; 2423 float ox = corner * dx;
1983 2424
1984 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2425 glTexCoord2f (ox , dy ); glVertex2i (px , py );
1985 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2426 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
1986 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2427 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
1987 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2428 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
1988 }
1989 }
1990 } 2429 }
1991 } 2430 }
1992 } 2431 }
1993 } 2432 }
1994 2433
1995 glEnd (); 2434 glEnd ();
1996 glDisable (GL_TEXTURE_2D); 2435 glDisable (GL_TEXTURE_2D);
1997 key.texname = -1; 2436 key.texname = -1;
1998 } 2437 }
1999
2000 hv_clear (smooth);
2001 } 2438 }
2002 2439
2440 if (pl_tex.name)
2441 {
2442 maptex tex = pl_tex;
2443 int px = pl_x + sdx;
2444 int py = pl_y + sdy;
2445
2446 key.texname = tex.name;
2447 rc_t::array_t &arr = rc.array (key);
2448
2449 arr.t2f_v3f (0 , 0 , px , py , 0);
2450 arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2451 arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2452 arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2453
2454 rc.draw ();
2455 }
2456
2457 rc_ov.draw ();
2458 rc_ov.clear ();
2459
2003 glDisable (GL_BLEND); 2460 glDisable (GL_BLEND);
2004 rc_free (rc);
2005 2461
2006 // top layer: overlays such as the health bar 2462 // top layer: overlays such as the health bar
2007 for (y = 0; y < sh; y++) 2463 for (y = 0; y < sh; y++)
2008 if (0 <= y + my && y + my < self->rows) 2464 if (0 <= y + my && y + my < self->rows)
2009 { 2465 {
… …
2012 for (x = 0; x < sw; x++) 2468 for (x = 0; x < sw; x++)
2013 if (row->c0 <= x + mx && x + mx < row->c1) 2469 if (row->c0 <= x + mx && x + mx < row->c1)
2014 { 2470 {
2015 mapcell *cell = row->col + (x + mx - row->c0); 2471 mapcell *cell = row->col + (x + mx - row->c0);
2016 2472
2017 int px = x * T; 2473 int px = x * Tw;
2018 int py = y * T; 2474 int py = y * Th;
2475
2476 if (expect_false (cell->player == player))
2477 {
2478 px += sdx;
2479 py += sdy;
2480 }
2019 2481
2020 if (cell->stat_hp) 2482 if (cell->stat_hp)
2021 { 2483 {
2022 int width = cell->stat_width * T; 2484 int width = cell->stat_width * Tw;
2023 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2485 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2024 2486
2025 glColor3ub (0, 0, 0); 2487 glColor3ub (0, 0, 0);
2026 glRectf (px + 1, py - thick - 2, 2488 glRectf (px + 1, py - thick - 2,
2027 px + width - 1, py); 2489 px + width - 1, py);
2028 2490
… …
2034 } 2496 }
2035 } 2497 }
2036} 2498}
2037 2499
2038void 2500void
2039draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data) 2501draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2040 CODE: 2502 CODE:
2041{ 2503{
2042 static float color[16][3] = { 2504 static float color[16][3] = {
2043 { 0.00F, 0.00F, 0.00F }, 2505 { 0.00f, 0.00f, 0.00f },
2044 { 1.00F, 1.00F, 1.00F }, 2506 { 1.00f, 1.00f, 1.00f },
2045 { 0.00F, 0.00F, 0.55F }, 2507 { 0.00f, 0.00f, 0.55f },
2046 { 1.00F, 0.00F, 0.00F }, 2508 { 1.00f, 0.00f, 0.00f },
2047 2509
2048 { 1.00F, 0.54F, 0.00F }, 2510 { 1.00f, 0.54f, 0.00f },
2049 { 0.11F, 0.56F, 1.00F }, 2511 { 0.11f, 0.56f, 1.00f },
2050 { 0.93F, 0.46F, 0.00F }, 2512 { 0.93f, 0.46f, 0.00f },
2051 { 0.18F, 0.54F, 0.34F }, 2513 { 0.18f, 0.54f, 0.34f },
2052 2514
2053 { 0.56F, 0.73F, 0.56F }, 2515 { 0.56f, 0.73f, 0.56f },
2054 { 0.80F, 0.80F, 0.80F }, 2516 { 0.80f, 0.80f, 0.80f },
2055 { 0.55F, 0.41F, 0.13F }, 2517 { 0.55f, 0.41f, 0.13f },
2056 { 0.99F, 0.77F, 0.26F }, 2518 { 0.99f, 0.77f, 0.26f },
2057 2519
2058 { 0.74F, 0.65F, 0.41F }, 2520 { 0.74f, 0.65f, 0.41f },
2059 2521
2060 { 0.00F, 1.00F, 1.00F }, 2522 { 0.00f, 1.00f, 1.00f },
2061 { 1.00F, 0.00F, 1.00F }, 2523 { 1.00f, 0.00f, 1.00f },
2062 { 1.00F, 1.00F, 0.00F }, 2524 { 1.00f, 1.00f, 0.00f },
2063 }; 2525 };
2064 2526
2065 int x, y; 2527 int x, y;
2066 2528
2067 glEnable (GL_TEXTURE_2D); 2529 glEnable (GL_TEXTURE_2D);
2530 /* GL_REPLACE would be correct, as we don't need to modulate alpha,
2531 * but the nvidia driver (185.18.14) mishandles alpha textures
2532 * and takes the colour from god knows where instead of using
2533 * Cp. MODULATE results in the same colour, but slightly different
2534 * alpha, but atcually gives us the correct colour with nvidia.
2535 */
2068 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2536 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2069 glEnable (GL_BLEND); 2537 glEnable (GL_BLEND);
2070 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2538 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2071 glBegin (GL_QUADS); 2539 glBegin (GL_QUADS);
2072 2540
2073 for (y = 0; y < h; y++) 2541 for (y = 0; y < h; y++)
… …
2077 2545
2078 if (m) 2546 if (m)
2079 { 2547 {
2080 float *c = color [m & 15]; 2548 float *c = color [m & 15];
2081 2549
2082 float tx1 = m & 0x40 ? 0.5 : 0.; 2550 float tx1 = m & 0x40 ? 0.5f : 0.f;
2083 float tx2 = tx1 + 0.5; 2551 float tx2 = tx1 + 0.5f;
2084 2552
2085 glColor4f (c[0], c[1], c[2], 0.75); 2553 glColor4f (c[0], c[1], c[2], 1);
2086 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2554 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2087 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2555 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2088 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2556 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2089 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2557 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2090 } 2558 }
… …
2094 glDisable (GL_BLEND); 2562 glDisable (GL_BLEND);
2095 glDisable (GL_TEXTURE_2D); 2563 glDisable (GL_TEXTURE_2D);
2096} 2564}
2097 2565
2098void 2566void
2099fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh) 2567fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2100 PPCODE: 2568 PPCODE:
2101{ 2569{
2102 int x, y; 2570 int x, y;
2103 int sw1 = sw + 2; 2571 int sw1 = sw + 2;
2104 int sh1 = sh + 2; 2572 int sh1 = sh + 2;
2105 int sh3 = sh * 3; 2573 int sh3 = sh * 3;
2106 int sw34 = (sw * 3 + 3) & ~3; 2574 int sw3 = sw * 3;
2575 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2576 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2107 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2577 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2108 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2578 memset (darkness1, 0, sw1*sh1);
2109 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2110 2579
2111 SvPOK_only (darkness3_sv); 2580 SvPOK_only (darkness3_sv);
2112 SvCUR_set (darkness3_sv, sw34 * sh3); 2581 SvCUR_set (darkness3_sv, sw3 * sh3);
2113 2582
2114 mx += self->x - 1; 2583 mx += self->x - 1;
2115 my += self->y - 1; 2584 my += self->y - 1;
2116
2117 memset (darkness1, 255, sw1 * sh1);
2118 2585
2119 for (y = 0; y < sh1; y++) 2586 for (y = 0; y < sh1; y++)
2120 if (0 <= y + my && y + my < self->rows) 2587 if (0 <= y + my && y + my < self->rows)
2121 { 2588 {
2122 maprow *row = self->row + (y + my); 2589 maprow *row = self->row + (y + my);
… …
2125 if (row->c0 <= x + mx && x + mx < row->c1) 2592 if (row->c0 <= x + mx && x + mx < row->c1)
2126 { 2593 {
2127 mapcell *cell = row->col + (x + mx - row->c0); 2594 mapcell *cell = row->col + (x + mx - row->c0);
2128 2595
2129 darkness1 [y * sw1 + x] = cell->darkness 2596 darkness1 [y * sw1 + x] = cell->darkness
2130 ? 255 - (cell->darkness - 1) 2597 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2131 : 255 - FOW_DARKNESS; 2598 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2132 } 2599 }
2133 } 2600 }
2134 2601
2135 for (y = 0; y < sh; ++y) 2602 for (y = 0; y < sh; ++y)
2136 for (x = 0; x < sw; ++x) 2603 for (x = 0; x < sw; ++x)
… …
2155 2622
2156 uint8_t r13 = (d13 + d23 + d12) / 3; 2623 uint8_t r13 = (d13 + d23 + d12) / 3;
2157 uint8_t r23 = d23; 2624 uint8_t r23 = d23;
2158 uint8_t r33 = (d23 + d33 + d32) / 3; 2625 uint8_t r33 = (d23 + d33 + d32) / 3;
2159 2626
2160 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2627 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2161 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2628 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2162 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2629 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2163 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2630 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2164 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22); 2631 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2165 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2632 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2166 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2633 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2167 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2634 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2168 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2635 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2169 } 2636 }
2170 2637
2171 free (darkness1); 2638 free (darkness1);
2172 2639
2173 EXTEND (SP, 3); 2640 EXTEND (SP, 3);
2174 PUSHs (sv_2mortal (newSViv (sw34))); 2641 PUSHs (sv_2mortal (newSViv (sw3)));
2175 PUSHs (sv_2mortal (newSViv (sh3))); 2642 PUSHs (sv_2mortal (newSViv (sh3)));
2176 PUSHs (darkness3_sv); 2643 PUSHs (darkness3_sv);
2177} 2644}
2178 2645
2179SV * 2646SV *
2180get_rect (CFPlus::Map self, int x0, int y0, int w, int h) 2647get_rect (DC::Map self, int x0, int y0, int w, int h)
2181 CODE: 2648 CODE:
2182{ 2649{
2183 int x, y, x1, y1; 2650 int x, y, x1, y1;
2184 SV *data_sv = newSV (w * h * 7 + 5); 2651 SV *data_sv = newSV (w * h * 7 + 5);
2185 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2652 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
2242 else 2709 else
2243 *data++ = 0; 2710 *data++ = 0;
2244 } 2711 }
2245 } 2712 }
2246 2713
2714 /* if size is w*h + 5 then no data has been found */
2715 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2716 {
2247 SvPOK_only (data_sv); 2717 SvPOK_only (data_sv);
2248 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2718 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2719 }
2720
2249 RETVAL = data_sv; 2721 RETVAL = data_sv;
2250} 2722}
2251 OUTPUT: 2723 OUTPUT:
2252 RETVAL 2724 RETVAL
2253 2725
2254void 2726void
2255set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2727set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2256 PPCODE: 2728 PPCODE:
2257{ 2729{
2258 int x, y, z; 2730 int x, y, z;
2259 int w, h; 2731 int w, h;
2260 int x1, y1; 2732 int x1, y1;
2733 STRLEN len;
2734 uint8_t *data, *end;
2735
2736 len = SvLEN (data_sv);
2737 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2738 data = (uint8_t *)SvPVbyte_nolen (data_sv);
2739 end = data + len + 8;
2740
2741 if (len < 5)
2742 XSRETURN_EMPTY;
2261 2743
2262 if (*data++ != 0) 2744 if (*data++ != 0)
2263 XSRETURN_EMPTY; /* version mismatch */ 2745 XSRETURN_EMPTY; /* version mismatch */
2264 2746
2265 w = *data++ << 8; w |= *data++; 2747 w = *data++ << 8; w |= *data++;
… …
2280 { 2762 {
2281 maprow *row = map_get_row (self, y); 2763 maprow *row = map_get_row (self, y);
2282 2764
2283 for (x = x0; x < x1; x++) 2765 for (x = x0; x < x1; x++)
2284 { 2766 {
2767 uint8_t flags;
2768
2769 if (data + 7 >= end)
2770 XSRETURN_EMPTY;
2771
2285 uint8_t flags = *data++; 2772 flags = *data++;
2286 2773
2287 if (flags) 2774 if (flags)
2288 { 2775 {
2289 mapcell *cell = row_get_cell (row, x); 2776 mapcell *cell = row_get_cell (row, x);
2290 tileid tile[3] = { 0, 0, 0 }; 2777 tileid tile[3] = { 0, 0, 0 };
… …
2293 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2780 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2294 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2781 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2295 2782
2296 if (cell->darkness == 0) 2783 if (cell->darkness == 0)
2297 { 2784 {
2298 cell->darkness = 0; 2785 /*cell->darkness = 0;*/
2786 EXTEND (SP, 3);
2299 2787
2300 for (z = 0; z <= 2; z++) 2788 for (z = 0; z <= 2; z++)
2301 { 2789 {
2302 tileid t = tile [z]; 2790 tileid t = tile [z];
2303 2791
2304 if (t >= self->texs || (t && !self->tex [t].name)) 2792 if (t >= self->tex.size () || (t && !self->tex[t].name))
2305 { 2793 {
2306 XPUSHs (sv_2mortal (newSViv (t))); 2794 PUSHs (sv_2mortal (newSViv (t)));
2307 need_texid (self, t); 2795 if (self->tex.size () <= t) self->tex.resize (t + 1);
2308 } 2796 }
2309 2797
2310 cell->tile [z] = t; 2798 cell->tile[z] = t;
2311 } 2799 }
2312 } 2800 }
2313 } 2801 }
2314 } 2802 }
2315 } 2803 }
2316} 2804}
2317 2805
2318MODULE = CFPlus PACKAGE = CFPlus::RW 2806MODULE = Deliantra::Client PACKAGE = DC::RW
2319 2807
2320CFPlus::RW 2808DC::RW
2321new (SV *class, SV *data_sv) 2809new (SV *klass, SV *data_sv)
2322 CODE: 2810 CODE:
2323{ 2811{
2324 STRLEN datalen; 2812 STRLEN datalen;
2325 char *data = SvPVbyte (data_sv, datalen); 2813 char *data = SvPVbyte (data_sv, datalen);
2326 2814
2327 RETVAL = SDL_RWFromConstMem (data, datalen); 2815 RETVAL = SDL_RWFromConstMem (data, datalen);
2328} 2816}
2329 OUTPUT: 2817 OUTPUT:
2330 RETVAL 2818 RETVAL
2331 2819
2332CFPlus::RW 2820DC::RW
2333new_from_file (SV *class, const char *path, const char *mode = "rb") 2821new_from_file (SV *klass, const char *path, const char *mode = "rb")
2334 CODE: 2822 CODE:
2335 RETVAL = SDL_RWFromFile (path, mode); 2823 RETVAL = SDL_RWFromFile (path, mode);
2336 OUTPUT: 2824 OUTPUT:
2337 RETVAL 2825 RETVAL
2338 2826
2339# fails on win32: 2827# fails on win32:
2340# CFPlus.xs(2268) : error C2059: syntax error : '(' 2828# dc.xs(2268) : error C2059: syntax error : '('
2341#void 2829#void
2342#close (CFPlus::RW self) 2830#close (DC::RW self)
2343# CODE: 2831# CODE:
2344# (self->(close)) (self); 2832# (self->(close)) (self);
2345 2833
2346MODULE = CFPlus PACKAGE = CFPlus::Channel 2834MODULE = Deliantra::Client PACKAGE = DC::Channel
2347 2835
2348PROTOTYPES: DISABLE 2836PROTOTYPES: DISABLE
2349 2837
2350CFPlus::Channel 2838DC::Channel
2351find () 2839find ()
2352 CODE: 2840 CODE:
2353{ 2841{
2354 RETVAL = Mix_GroupAvailable (-1); 2842 RETVAL = Mix_GroupAvailable (-1);
2355 2843
2356 if (RETVAL < 0) 2844 if (RETVAL < 0)
2357 { 2845 {
2358 RETVAL = Mix_GroupOldest (-1); 2846 RETVAL = Mix_GroupOldest (-1);
2359 2847
2360 if (RETVAL < 0) 2848 if (RETVAL < 0)
2849 {
2850 // happens sometimes, maybe it just stopped playing(?)
2851 RETVAL = Mix_GroupAvailable (-1);
2852
2853 if (RETVAL < 0)
2361 XSRETURN_UNDEF; 2854 XSRETURN_UNDEF;
2362 2855 }
2856 else
2363 Mix_HaltChannel (RETVAL); 2857 Mix_HaltChannel (RETVAL);
2364 } 2858 }
2365 2859
2366 Mix_UnregisterAllEffects (RETVAL); 2860 Mix_UnregisterAllEffects (RETVAL);
2367 Mix_Volume (RETVAL, 128); 2861 Mix_Volume (RETVAL, 128);
2368} 2862}
2369 OUTPUT: 2863 OUTPUT:
2370 RETVAL 2864 RETVAL
2371 2865
2372void 2866void
2373halt (CFPlus::Channel self) 2867halt (DC::Channel self)
2374 CODE: 2868 CODE:
2375 Mix_HaltChannel (self); 2869 Mix_HaltChannel (self);
2376 2870
2377void 2871void
2378expire (CFPlus::Channel self, int ticks = -1) 2872expire (DC::Channel self, int ticks = -1)
2379 CODE: 2873 CODE:
2380 Mix_ExpireChannel (self, ticks); 2874 Mix_ExpireChannel (self, ticks);
2381 2875
2382void 2876void
2383fade_out (CFPlus::Channel self, int ticks = -1) 2877fade_out (DC::Channel self, int ticks = -1)
2384 CODE: 2878 CODE:
2385 Mix_FadeOutChannel (self, ticks); 2879 Mix_FadeOutChannel (self, ticks);
2386 2880
2387int 2881int
2388volume (CFPlus::Channel self, int volume) 2882volume (DC::Channel self, int volume)
2389 CODE: 2883 CODE:
2390 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128)); 2884 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2391 OUTPUT: 2885 OUTPUT:
2392 RETVAL 2886 RETVAL
2393 2887
2394void 2888void
2395unregister_all_effects (CFPlus::Channel self) 2889unregister_all_effects (DC::Channel self)
2396 CODE: 2890 CODE:
2397 Mix_UnregisterAllEffects (self); 2891 Mix_UnregisterAllEffects (self);
2398 2892
2399void 2893void
2400set_panning (CFPlus::Channel self, int left, int right) 2894set_panning (DC::Channel self, int left, int right)
2401 CODE: 2895 CODE:
2402 left = CLAMP (left , 0, 255); 2896 left = CLAMP (left , 0, 255);
2403 right = CLAMP (right, 0, 255); 2897 right = CLAMP (right, 0, 255);
2404 Mix_SetPanning (self, left, right); 2898 Mix_SetPanning (self, left, right);
2405 2899
2406void 2900void
2407set_distance (CFPlus::Channel self, int distance) 2901set_distance (DC::Channel self, int distance)
2408 CODE: 2902 CODE:
2409 Mix_SetDistance (self, CLAMP (distance, 0, 255)); 2903 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2410 2904
2411void 2905void
2412set_position (CFPlus::Channel self, int angle, int distance) 2906set_position (DC::Channel self, int angle, int distance)
2413 CODE: 2907 CODE:
2414 2908
2415void 2909void
2416set_position_r (CFPlus::Channel self, int dx, int dy, int maxdistance) 2910set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2417 CODE: 2911 CODE:
2418{ 2912{
2419 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2913 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2420 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2914 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2421 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2915 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2422} 2916}
2423 2917
2424void 2918void
2425set_reverse_stereo (CFPlus::Channel self, int flip) 2919set_reverse_stereo (DC::Channel self, int flip)
2426 CODE: 2920 CODE:
2427 Mix_SetReverseStereo (self, flip); 2921 Mix_SetReverseStereo (self, flip);
2428 2922
2429MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2923MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2430 2924
2431PROTOTYPES: DISABLE 2925PROTOTYPES: DISABLE
2432 2926
2927void
2928decoders ()
2929 PPCODE:
2930#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2931 int i, num = Mix_GetNumChunkDecoders ();
2932 EXTEND (SP, num);
2933 for (i = 0; i < num; ++i)
2934 PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
2935#else
2936 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2937#endif
2938
2433CFPlus::MixChunk 2939DC::MixChunk
2434new (SV *class, CFPlus::RW rwops) 2940new (SV *klass, DC::RW rwops)
2435 CODE: 2941 CODE:
2436 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2942 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2437 OUTPUT: 2943 OUTPUT:
2438 RETVAL 2944 RETVAL
2439 2945
2440void 2946void
2441DESTROY (CFPlus::MixChunk self) 2947DESTROY (DC::MixChunk self)
2442 CODE: 2948 CODE:
2443 Mix_FreeChunk (self); 2949 Mix_FreeChunk (self);
2444 2950
2445int 2951int
2446volume (CFPlus::MixChunk self, int volume = -1) 2952volume (DC::MixChunk self, int volume = -1)
2447 CODE: 2953 CODE:
2448 if (items > 1) 2954 if (items > 1)
2449 volume = CLAMP (volume, 0, 128); 2955 volume = CLAMP (volume, 0, 128);
2450 RETVAL = Mix_VolumeChunk (self, volume); 2956 RETVAL = Mix_VolumeChunk (self, volume);
2451 OUTPUT: 2957 OUTPUT:
2452 RETVAL 2958 RETVAL
2453 2959
2454CFPlus::Channel 2960DC::Channel
2455play (CFPlus::MixChunk self, CFPlus::Channel channel = -1, int loops = 0, int ticks = -1) 2961play (DC::MixChunk self, DC::Channel channel = -1, int loops = 0, int ticks = -1)
2456 CODE: 2962 CODE:
2457{ 2963{
2458 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2964 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2459 2965
2460 if (RETVAL < 0) 2966 if (RETVAL < 0)
… …
2467 } 2973 }
2468} 2974}
2469 OUTPUT: 2975 OUTPUT:
2470 RETVAL 2976 RETVAL
2471 2977
2472MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2978MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2979
2980void
2981decoders ()
2982 PPCODE:
2983#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
2984 int i, num = Mix_GetNumMusicDecoders ();
2985 EXTEND (SP, num);
2986 for (i = 0; i < num; ++i)
2987 PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
2988#else
2989 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2990#endif
2473 2991
2474int 2992int
2475volume (int volume = -1) 2993volume (int volume = -1)
2476 PROTOTYPE: ;$ 2994 PROTOTYPE: ;$
2477 CODE: 2995 CODE:
… …
2489void 3007void
2490halt () 3008halt ()
2491 CODE: 3009 CODE:
2492 Mix_HaltMusic (); 3010 Mix_HaltMusic ();
2493 3011
3012int
3013playing ()
3014 CODE:
3015 RETVAL = Mix_PlayingMusic ();
3016 OUTPUT:
3017 RETVAL
3018
2494CFPlus::MixMusic 3019DC::MixMusic
2495new (SV *class, CFPlus::RW rwops) 3020new (SV *klass, DC::RW rwops)
2496 CODE: 3021 CODE:
2497 RETVAL = Mix_LoadMUS_RW (rwops); 3022 RETVAL = Mix_LoadMUS_RW (rwops);
2498 OUTPUT: 3023 OUTPUT:
2499 RETVAL 3024 RETVAL
2500 3025
2501void 3026void
2502DESTROY (CFPlus::MixMusic self) 3027DESTROY (DC::MixMusic self)
2503 CODE: 3028 CODE:
2504 Mix_FreeMusic (self); 3029 Mix_FreeMusic (self);
2505 3030
2506int 3031int
2507play (CFPlus::MixMusic self, int loops = -1) 3032play (DC::MixMusic self, int loops = -1)
2508 CODE: 3033 CODE:
2509 RETVAL = Mix_PlayMusic (self, loops); 3034 RETVAL = Mix_PlayMusic (self, loops);
2510 OUTPUT: 3035 OUTPUT:
2511 RETVAL 3036 RETVAL
2512 3037
2513void 3038void
2514fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position) 3039fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2515 CODE: 3040 CODE:
2516 Mix_FadeInMusicPos (self, loops, ms, position); 3041 Mix_FadeInMusicPos (self, loops, ms, position);
2517 3042
2518MODULE = CFPlus PACKAGE = CFPlus::OpenGL 3043MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2519 3044
2520PROTOTYPES: ENABLE 3045PROTOTYPES: ENABLE
2521 3046
2522BOOT: 3047BOOT:
2523{ 3048{
2524 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 3049 HV *stash = gv_stashpv ("DC::OpenGL", 1);
2525 static const struct { 3050 static const struct {
2526 const char *name; 3051 const char *name;
2527 IV iv; 3052 IV iv;
2528 } *civ, const_iv[] = { 3053 } *civ, const_iv[] = {
2529# define const_iv(name) { # name, (IV)name } 3054# define const_iv(name) { # name, (IV)name }
2530 const_iv (GL_VENDOR), 3055 const_iv (GL_VENDOR),
2531 const_iv (GL_VERSION), 3056 const_iv (GL_VERSION),
2532 const_iv (GL_EXTENSIONS), 3057 const_iv (GL_EXTENSIONS),
3058 const_iv (GL_MAX_TEXTURE_UNITS),
2533 const_iv (GL_COLOR_MATERIAL), 3059 const_iv (GL_COLOR_MATERIAL),
2534 const_iv (GL_SMOOTH), 3060 const_iv (GL_SMOOTH),
2535 const_iv (GL_FLAT), 3061 const_iv (GL_FLAT),
2536 const_iv (GL_DITHER), 3062 const_iv (GL_DITHER),
2537 const_iv (GL_BLEND), 3063 const_iv (GL_BLEND),
… …
2549 const_iv (GL_ZERO), 3075 const_iv (GL_ZERO),
2550 const_iv (GL_SRC_ALPHA), 3076 const_iv (GL_SRC_ALPHA),
2551 const_iv (GL_DST_ALPHA), 3077 const_iv (GL_DST_ALPHA),
2552 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3078 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2553 const_iv (GL_ONE_MINUS_DST_ALPHA), 3079 const_iv (GL_ONE_MINUS_DST_ALPHA),
3080 const_iv (GL_SRC_COLOR),
3081 const_iv (GL_DST_COLOR),
3082 const_iv (GL_ONE_MINUS_SRC_COLOR),
3083 const_iv (GL_ONE_MINUS_DST_COLOR),
2554 const_iv (GL_SRC_ALPHA_SATURATE), 3084 const_iv (GL_SRC_ALPHA_SATURATE),
2555 const_iv (GL_RGB), 3085 const_iv (GL_RGB),
2556 const_iv (GL_RGBA), 3086 const_iv (GL_RGBA),
2557 const_iv (GL_RGBA4), 3087 const_iv (GL_RGBA4),
2558 const_iv (GL_RGBA8), 3088 const_iv (GL_RGBA8),
… …
2626 const_iv (GL_NICEST), 3156 const_iv (GL_NICEST),
2627 const_iv (GL_V2F), 3157 const_iv (GL_V2F),
2628 const_iv (GL_V3F), 3158 const_iv (GL_V3F),
2629 const_iv (GL_T2F_V3F), 3159 const_iv (GL_T2F_V3F),
2630 const_iv (GL_T2F_N3F_V3F), 3160 const_iv (GL_T2F_N3F_V3F),
3161 const_iv (GL_FUNC_ADD),
3162 const_iv (GL_FUNC_SUBTRACT),
3163 const_iv (GL_FUNC_REVERSE_SUBTRACT),
2631# undef const_iv 3164# undef const_iv
2632 }; 3165 };
2633 3166
2634 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3167 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
2635 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3168 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2636 3169
2637 texture_av = newAV (); 3170 texture_av = newAV ();
2638 AvREAL_off (texture_av); 3171 AvREAL_off (texture_av);
2639} 3172}
2640 3173
… …
2642disable_GL_EXT_blend_func_separate () 3175disable_GL_EXT_blend_func_separate ()
2643 CODE: 3176 CODE:
2644 gl.BlendFuncSeparate = 0; 3177 gl.BlendFuncSeparate = 0;
2645 gl.BlendFuncSeparateEXT = 0; 3178 gl.BlendFuncSeparateEXT = 0;
2646 3179
2647char * 3180void
3181apple_nvidia_bug (int enable)
3182
3183const char *
2648gl_vendor () 3184gl_vendor ()
2649 CODE: 3185 CODE:
2650 RETVAL = (char *)glGetString (GL_VENDOR); 3186 RETVAL = (const char *)glGetString (GL_VENDOR);
2651 OUTPUT: 3187 OUTPUT:
2652 RETVAL 3188 RETVAL
2653 3189
2654char * 3190const char *
2655gl_version () 3191gl_version ()
2656 CODE: 3192 CODE:
2657 RETVAL = (char *)glGetString (GL_VERSION); 3193 RETVAL = (const char *)glGetString (GL_VERSION);
2658 OUTPUT: 3194 OUTPUT:
2659 RETVAL 3195 RETVAL
2660 3196
2661char * 3197const char *
2662gl_extensions () 3198gl_extensions ()
2663 CODE: 3199 CODE:
2664 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3200 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2665 OUTPUT: 3201 OUTPUT:
2666 RETVAL 3202 RETVAL
2667 3203
2668const char *glGetString (GLenum pname) 3204const char *glGetString (GLenum pname)
3205 CODE:
3206 RETVAL = (const char *)glGetString (pname);
3207 OUTPUT:
3208 RETVAL
2669 3209
2670GLint glGetInteger (GLenum pname) 3210GLint glGetInteger (GLenum pname)
2671 CODE: 3211 CODE:
2672 glGetIntegerv (pname, &RETVAL); 3212 glGetIntegerv (pname, &RETVAL);
2673 OUTPUT: 3213 OUTPUT:
… …
2681 3221
2682int glGetError () 3222int glGetError ()
2683 3223
2684void glFinish () 3224void glFinish ()
2685 3225
3226void glFlush ()
3227
2686void glClear (int mask) 3228void glClear (int mask)
2687 3229
2688void glClearColor (float r, float g, float b, float a = 1.0) 3230void glClearColor (float r, float g, float b, float a = 1.0)
2689 PROTOTYPE: @ 3231 PROTOTYPE: @
2690 3232
… …
2699void glBlendFunc (int sfactor, int dfactor) 3241void glBlendFunc (int sfactor, int dfactor)
2700 3242
2701void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3243void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2702 CODE: 3244 CODE:
2703 gl_BlendFuncSeparate (sa, da, saa, daa); 3245 gl_BlendFuncSeparate (sa, da, saa, daa);
3246
3247# void glBlendEquation (int se)
2704 3248
2705void glDepthMask (int flag) 3249void glDepthMask (int flag)
2706 3250
2707void glLogicOp (int opcode) 3251void glLogicOp (int opcode)
2708 3252
… …
2743void glRotate (float angle, float x, float y, float z) 3287void glRotate (float angle, float x, float y, float z)
2744 CODE: 3288 CODE:
2745 glRotatef (angle, x, y, z); 3289 glRotatef (angle, x, y, z);
2746 3290
2747void glColor (float r, float g, float b, float a = 1.0) 3291void glColor (float r, float g, float b, float a = 1.0)
3292 PROTOTYPE: @
2748 ALIAS: 3293 ALIAS:
2749 glColor_premultiply = 1 3294 glColor_premultiply = 1
2750 CODE: 3295 CODE:
2751 if (ix) 3296 if (ix)
2752 { 3297 {
… …
2822void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column) 3367void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2823 CODE: 3368 CODE:
2824 if (gl.SeparableFilter2D) 3369 if (gl.SeparableFilter2D)
2825 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3370 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2826 3371
2827void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data) 3372void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data = 0)
2828 3373
2829void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 3374void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2830 3375
2831void glDrawPixels (int width, int height, int format, int type, char *pixels) 3376void glDrawPixels (int width, int height, int format, int type, char *pixels)
2832 3377
… …
2858 3403
2859void glEndList () 3404void glEndList ()
2860 3405
2861void glCallList (int list) 3406void glCallList (int list)
2862 3407
2863MODULE = CFPlus PACKAGE = CFPlus::UI::Base 3408void c_init ()
3409 CODE:
3410 glPixelStorei (GL_PACK_ALIGNMENT , 1);
3411 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
3412
3413MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2864 3414
2865PROTOTYPES: DISABLE 3415PROTOTYPES: DISABLE
2866 3416
2867void 3417void
2868find_widget (SV *self, NV x, NV y) 3418find_widget (SV *self, NV x, NV y)
2869 PPCODE: 3419 PPCODE:
2870{ 3420{
2871 if (within_widget (self, x, y)) 3421 if (within_widget (self, x, y))
2872 XPUSHs (self); 3422 XPUSHs (self);
2873} 3423}
2874 3424
2875BOOT: 3425BOOT:
2876{ 3426{
2877 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV); 3427 hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
2878 3428
2879 draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV); 3429 draw_x_gv = gv_fetchpv ("DC::UI::Base::draw_x", 1, SVt_NV);
2880 draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV); 3430 draw_y_gv = gv_fetchpv ("DC::UI::Base::draw_y", 1, SVt_NV);
2881 draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV); 3431 draw_w_gv = gv_fetchpv ("DC::UI::Base::draw_w", 1, SVt_NV);
2882 draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV); 3432 draw_h_gv = gv_fetchpv ("DC::UI::Base::draw_h", 1, SVt_NV);
2883} 3433}
2884 3434
2885void 3435void
2886draw (SV *self) 3436draw (SV *self)
2887 CODE: 3437 CODE:
2888{ 3438{
2889 HV *hv; 3439 HV *hv;
2890 SV **svp; 3440 SV **svp;
2891 NV x, y, w, h; 3441 NV x, y, w, h;
2892 SV *draw_x_sv = GvSV (draw_x_gv); 3442 SV *draw_x_sv = GvSV (draw_x_gv);
2893 SV *draw_y_sv = GvSV (draw_y_gv); 3443 SV *draw_y_sv = GvSV (draw_y_gv);
2894 SV *draw_w_sv = GvSV (draw_w_gv); 3444 SV *draw_w_sv = GvSV (draw_w_gv);
2895 SV *draw_h_sv = GvSV (draw_h_gv); 3445 SV *draw_h_sv = GvSV (draw_h_gv);
2896 double draw_x, draw_y; 3446 double draw_x, draw_y;
2897 3447
2898 if (!SvROK (self)) 3448 if (!SvROK (self))
2899 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self)); 3449 croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
2900 3450
2901 hv = (HV *)SvRV (self); 3451 hv = (HV *)SvRV (self);
2902 3452
2903 if (SvTYPE (hv) != SVt_PVHV) 3453 if (SvTYPE (hv) != SVt_PVHV)
2904 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self)); 3454 croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
2905 3455
2906 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.; 3456 svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2907 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.; 3457 svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2908 3458
2909 if (!h || !w) 3459 if (!h || !w)

Diff Legend

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