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

Diff Legend

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