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.221 by root, Fri Aug 10 04:02:13 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
1555SV * 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;
… …
1582 2086
1583 //TODO: don't trust server data to be in-range(!) 2087 //TODO: don't trust server data to be in-range(!)
1584 2088
1585 if (flags & 8) 2089 if (flags & 8)
1586 { 2090 {
2091 uint8_t ext, cmd;
2092
1587 if (extmap) 2093 do
1588 { 2094 {
1589 uint8_t ext, cmd; 2095 ext = *data++;
2096 cmd = ext & 0x7f;
1590 2097
1591 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
1592 { 2101 {
1593 ext = *data++;
1594 cmd = ext & 0x3f;
1595
1596 if (cmd < 4)
1597 cell->darkness = 255 - ext * 64 + 1;
1598 else if (cmd == 5) // health
1599 {
1600 cell->stat_width = 1; 2102 cell->stat_width = 1;
1601 cell->stat_hp = *data++; 2103 cell->stat_hp = *data++;
1602 }
1603 else if (cmd == 6) // monster width
1604 cell->stat_width = *data++ + 1;
1605 else if (cmd == 0x47)
1606 {
1607 if (*data == 4)
1608 ; // decode player count
1609
1610 data += *data + 1;
1611 }
1612 else if (cmd == 8) // cell flags
1613 cell->flags = *data++;
1614 else if (ext & 0x40) // unknown, multibyte => skip
1615 data += *data + 1;
1616 else
1617 data++;
1618 } 2104 }
1619 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++;
1620 } 2122 }
1621 else 2123 while (ext & 0x80);
1622 cell->darkness = *data++ + 1;
1623 } 2124 }
1624 2125
1625 for (z = 0; z <= 2; ++z) 2126 for (z = 0; z <= 2; ++z)
1626 if (flags & (4 >> z)) 2127 if (flags & (4 >> z))
1627 { 2128 {
… …
1630 cell->tile [z] = self->face2tile [face]; 2131 cell->tile [z] = self->face2tile [face];
1631 2132
1632 if (cell->tile [z]) 2133 if (cell->tile [z])
1633 { 2134 {
1634 maptex *tex = self->tex + cell->tile [z]; 2135 maptex *tex = self->tex + cell->tile [z];
2136 tex->unused = 0;
1635 if (!tex->name) 2137 if (!tex->name)
1636 av_push (missing, newSViv (cell->tile [z])); 2138 av_push (missing, newSViv (cell->tile [z]));
1637 2139
1638 if (tex->smoothtile) 2140 if (tex->smoothtile)
1639 { 2141 {
1640 maptex *smooth = self->tex + tex->smoothtile; 2142 maptex *smooth = self->tex + tex->smoothtile;
2143 smooth->unused = 0;
1641 if (!smooth->name) 2144 if (!smooth->name)
1642 av_push (missing, newSViv (tex->smoothtile)); 2145 av_push (missing, newSViv (tex->smoothtile));
1643 } 2146 }
1644 } 2147 }
1645 } 2148 }
1646 } 2149 }
1647 else 2150 else
1648 cell->darkness = 0; 2151 CELL_CLEAR (cell);
1649 } 2152 }
1650} 2153}
1651 OUTPUT: 2154 OUTPUT:
1652 RETVAL 2155 RETVAL
1653 2156
1654SV * 2157SV *
1655mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 2158mapmap (DC::Map self, int x0, int y0, int w, int h)
1656 CODE: 2159 CODE:
1657{ 2160{
1658 int x1, x; 2161 int x1, x;
1659 int y1, y; 2162 int y1, y;
1660 int z; 2163 int z;
… …
1673 ? self->row + y 2176 ? self->row + y
1674 : 0; 2177 : 0;
1675 2178
1676 for (x = x0; x < x1; x++) 2179 for (x = x0; x < x1; x++)
1677 { 2180 {
1678 int r = 32, g = 32, b = 32, a = 192; 2181 unsigned int r = 32, g = 32, b = 32, a = 192;
1679 2182
1680 if (row && row->c0 <= x && x < row->c1) 2183 if (row && row->c0 <= x && x < row->c1)
1681 { 2184 {
1682 mapcell *cell = row->col + (x - row->c0); 2185 mapcell *cell = row->col + (x - row->c0);
1683 2186
… …
1685 { 2188 {
1686 maptex tex = self->tex [cell->tile [z]]; 2189 maptex tex = self->tex [cell->tile [z]];
1687 int a0 = 255 - tex.a; 2190 int a0 = 255 - tex.a;
1688 int a1 = tex.a; 2191 int a1 = tex.a;
1689 2192
1690 r = (r * a0 + tex.r * a1) / 255; 2193 r = div255 (r * a0 + tex.r * a1);
1691 g = (g * a0 + tex.g * a1) / 255; 2194 g = div255 (g * a0 + tex.g * a1);
1692 b = (b * a0 + tex.b * a1) / 255; 2195 b = div255 (b * a0 + tex.b * a1);
1693 a = (a * a0 + tex.a * a1) / 255; 2196 a = div255 (a * a0 + tex.a * a1);
1694 } 2197 }
1695 } 2198 }
1696 2199
1697 *map++ = (r ) 2200 *map++ = (r )
1698 | (g << 8) 2201 | (g << 8)
1699 | (b << 16) 2202 | (b << 16)
1700 | (a << 24); 2203 | (a << 24);
1701 } 2204 }
1702 } 2205 }
1703 2206
1704 RETVAL = map_sv; 2207 RETVAL = map_sv;
1705} 2208}
1706 OUTPUT: 2209 OUTPUT:
1707 RETVAL 2210 RETVAL
1708 2211
1709void 2212void
1710draw (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)
1711 CODE: 2214 CODE:
1712{ 2215{
1713 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1714 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1715 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1716 smooth_key skey;
1717 int x, y, z; 2216 int x, y, z;
1718 int last_name;
1719 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
1720 // thats current max. sorry. 2228 // that's current max. sorry.
1721 if (sw > 255) sw = 255; 2229 if (sw > 255) sw = 255;
1722 if (sh > 255) sh = 255; 2230 if (sh > 255) sh = 255;
1723 2231
1724 // clear key, in case of extra padding
1725 memset (&skey, 0, sizeof (skey)); 2232 memset (&key, 0, sizeof (key));
1726 2233 key.r = 255;
1727 glColor4ub (255, 255, 255, 255); 2234 key.g = 255;
1728 2235 key.b = 255;
1729 glEnable (GL_BLEND); 2236 key.a = 255;
1730 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2237 key.mode = GL_QUADS;
1731 glEnable (GL_TEXTURE_2D); 2238 key.format = GL_T2F_V3F;
1732 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1733
1734 glBegin (GL_QUADS);
1735
1736 last_name = -1;
1737 2239
1738 mx += self->x; 2240 mx += self->x;
1739 my += self->y; 2241 my += self->y;
1740 2242
1741 // first pass: determine smooth_max 2243 // first pass: determine smooth_max
1742 // rather ugly, if you ask me 2244 // rather ugly, if you ask me
1743 // could also be stored inside mapcell and updated on change 2245 // could also be stored inside mapcell and updated on change
1744 memset (smooth_max, 0, sizeof (smooth_max)); 2246 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1745 2247
1746 for (y = 0; y < sh; y++) 2248 for (y = 0; y < sh; y++)
1747 if (0 <= y + my && y + my < self->rows) 2249 if (0 <= y + my && y + my < self->rows)
1748 { 2250 {
1749 maprow *row = self->row + (y + my); 2251 maprow *row = self->row + (y + my);
… …
1758 MAX (self->tex [cell->tile [1]].smoothlevel, 2260 MAX (self->tex [cell->tile [1]].smoothlevel,
1759 self->tex [cell->tile [2]].smoothlevel)); 2261 self->tex [cell->tile [2]].smoothlevel));
1760 } 2262 }
1761 } 2263 }
1762 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
1763 for (z = 0; z <= 2; z++) 2269 for (z = 0; z <= 2; z++)
1764 { 2270 {
1765 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;
1766 2275
1767 for (y = 0; y < sh; y++) 2276 for (y = 0; y < sh; y++)
1768 if (0 <= y + my && y + my < self->rows) 2277 if (0 <= y + my && y + my < self->rows)
1769 { 2278 {
1770 maprow *row = self->row + (y + my); 2279 maprow *row = self->row + (y + my);
… …
1778 if (tile) 2287 if (tile)
1779 { 2288 {
1780 maptex tex = self->tex [tile]; 2289 maptex tex = self->tex [tile];
1781 int px, py; 2290 int px, py;
1782 2291
1783 // suppressing texture state switches here
1784 // is only moderately effective, but worth the extra effort
1785 if (last_name != tex.name) 2292 if (key.texname != tex.name)
1786 { 2293 {
2294 self->tex [tile].unused = 0;
2295
1787 if (!tex.name) 2296 if (!tex.name)
1788 tex = self->tex [2]; /* missing, replace by noface */ 2297 tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
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 continue; // smoothing not yet available
1903
1904 glEnd (); 2418 glEnd ();
1905 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 2419 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1906 glBegin (GL_QUADS); 2420 glBegin (GL_QUADS);
1907 } 2421 }
1908 2422
1909 if (border) 2423 if (border)
1910 { 2424 {
1911 float ox = border * dx; 2425 float ox = border * dx;
1912 2426
1913 glTexCoord2f (ox , 0.f ); glVertex2f (px , py ); 2427 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1914 glTexCoord2f (ox , dy ); glVertex2f (px , py + T); 2428 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
1915 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T); 2429 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
1916 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py ); 2430 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
1917 } 2431 }
1918 2432
1919 if (corner) 2433 if (corner)
1920 { 2434 {
1921 float ox = corner * dx; 2435 float ox = corner * dx;
1922 2436
1923 glTexCoord2f (ox , dy ); glVertex2f (px , py ); 2437 glTexCoord2f (ox , dy ); glVertex2i (px , py );
1924 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T); 2438 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
1925 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T); 2439 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
1926 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py ); 2440 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
1927 }
1928 } 2441 }
1929 } 2442 }
1930 } 2443 }
1931 } 2444 }
2445
2446 glEnd ();
2447 glDisable (GL_TEXTURE_2D);
2448 key.texname = -1;
1932 } 2449 }
1933
1934 hv_clear (smooth);
1935 } 2450 }
1936 2451
1937 glEnd (); 2452 if (pl_tex.name)
2453 {
2454 maptex tex = pl_tex;
2455 int px = pl_x + sdx;
2456 int py = pl_y + sdy;
1938 2457
1939 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
1940 glDisable (GL_BLEND); 2472 glDisable (GL_BLEND);
1941 2473
1942 // top layer: overlays such as the health bar 2474 // top layer: overlays such as the health bar
1943 for (y = 0; y < sh; y++) 2475 for (y = 0; y < sh; y++)
1944 if (0 <= y + my && y + my < self->rows) 2476 if (0 <= y + my && y + my < self->rows)
… …
1948 for (x = 0; x < sw; x++) 2480 for (x = 0; x < sw; x++)
1949 if (row->c0 <= x + mx && x + mx < row->c1) 2481 if (row->c0 <= x + mx && x + mx < row->c1)
1950 { 2482 {
1951 mapcell *cell = row->col + (x + mx - row->c0); 2483 mapcell *cell = row->col + (x + mx - row->c0);
1952 2484
1953 int px = x * T; 2485 int px = x * Tw;
1954 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 }
1955 2493
1956 if (cell->stat_hp) 2494 if (cell->stat_hp)
1957 { 2495 {
1958 int width = cell->stat_width * T; 2496 int width = cell->stat_width * Tw;
1959 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2497 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
1960 2498
1961 glColor3ub (0, 0, 0); 2499 glColor3ub (0, 0, 0);
1962 glRectf (px + 1, py - thick - 2, 2500 glRectf (px + 1, py - thick - 2,
1963 px + width - 1, py); 2501 px + width - 1, py);
1964 2502
… …
1970 } 2508 }
1971 } 2509 }
1972} 2510}
1973 2511
1974void 2512void
1975draw_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)
1976 CODE: 2514 CODE:
1977{ 2515{
1978 static float color[16][3] = { 2516 static float color[16][3] = {
1979 { 0.00F, 0.00F, 0.00F }, 2517 { 0.00f, 0.00f, 0.00f },
1980 { 1.00F, 1.00F, 1.00F }, 2518 { 1.00f, 1.00f, 1.00f },
1981 { 0.00F, 0.00F, 0.55F }, 2519 { 0.00f, 0.00f, 0.55f },
1982 { 1.00F, 0.00F, 0.00F }, 2520 { 1.00f, 0.00f, 0.00f },
1983 2521
1984 { 1.00F, 0.54F, 0.00F }, 2522 { 1.00f, 0.54f, 0.00f },
1985 { 0.11F, 0.56F, 1.00F }, 2523 { 0.11f, 0.56f, 1.00f },
1986 { 0.93F, 0.46F, 0.00F }, 2524 { 0.93f, 0.46f, 0.00f },
1987 { 0.18F, 0.54F, 0.34F }, 2525 { 0.18f, 0.54f, 0.34f },
1988 2526
1989 { 0.56F, 0.73F, 0.56F }, 2527 { 0.56f, 0.73f, 0.56f },
1990 { 0.80F, 0.80F, 0.80F }, 2528 { 0.80f, 0.80f, 0.80f },
1991 { 0.55F, 0.41F, 0.13F }, 2529 { 0.55f, 0.41f, 0.13f },
1992 { 0.99F, 0.77F, 0.26F }, 2530 { 0.99f, 0.77f, 0.26f },
1993 2531
1994 { 0.74F, 0.65F, 0.41F }, 2532 { 0.74f, 0.65f, 0.41f },
1995 2533
1996 { 0.00F, 1.00F, 1.00F }, 2534 { 0.00f, 1.00f, 1.00f },
1997 { 1.00F, 0.00F, 1.00F }, 2535 { 1.00f, 0.00f, 1.00f },
1998 { 1.00F, 1.00F, 0.00F }, 2536 { 1.00f, 1.00f, 0.00f },
1999 }; 2537 };
2000 2538
2001 int x, y; 2539 int x, y;
2002 2540
2003 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 */
2004 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2548 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2005 glEnable (GL_BLEND); 2549 glEnable (GL_BLEND);
2006 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2550 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2007 glBegin (GL_QUADS); 2551 glBegin (GL_QUADS);
2008 2552
2009 for (y = 0; y < h; y++) 2553 for (y = 0; y < h; y++)
… …
2013 2557
2014 if (m) 2558 if (m)
2015 { 2559 {
2016 float *c = color [m & 15]; 2560 float *c = color [m & 15];
2017 2561
2018 float tx1 = m & 0x40 ? 0.5 : 0.; 2562 float tx1 = m & 0x40 ? 0.5f : 0.f;
2019 float tx2 = tx1 + 0.5; 2563 float tx2 = tx1 + 0.5f;
2020 2564
2021 glColor4f (c[0], c[1], c[2], 0.75); 2565 glColor4f (c[0], c[1], c[2], 1);
2022 glTexCoord2f (tx1, 0.); glVertex2i (x , y ); 2566 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2023 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1); 2567 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2024 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1); 2568 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2025 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y ); 2569 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2026 } 2570 }
… …
2030 glDisable (GL_BLEND); 2574 glDisable (GL_BLEND);
2031 glDisable (GL_TEXTURE_2D); 2575 glDisable (GL_TEXTURE_2D);
2032} 2576}
2033 2577
2034void 2578void
2035fow_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)
2036 PPCODE: 2580 PPCODE:
2037{ 2581{
2038 int x, y; 2582 int x, y;
2039 int sw1 = sw + 2; 2583 int sw1 = sw + 2;
2040 int sh1 = sh + 2; 2584 int sh1 = sh + 2;
2041 int sh3 = sh * 3; 2585 int sh3 = sh * 3;
2042 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);
2043 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1); 2589 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2044 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3)); 2590 memset (darkness1, 0, sw1*sh1);
2045 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2046 2591
2047 SvPOK_only (darkness3_sv); 2592 SvPOK_only (darkness3_sv);
2048 SvCUR_set (darkness3_sv, sw34 * sh3); 2593 SvCUR_set (darkness3_sv, sw3 * sh3);
2049 2594
2050 mx += self->x - 1; 2595 mx += self->x - 1;
2051 my += self->y - 1; 2596 my += self->y - 1;
2052
2053 memset (darkness1, 255, sw1 * sh1);
2054 2597
2055 for (y = 0; y < sh1; y++) 2598 for (y = 0; y < sh1; y++)
2056 if (0 <= y + my && y + my < self->rows) 2599 if (0 <= y + my && y + my < self->rows)
2057 { 2600 {
2058 maprow *row = self->row + (y + my); 2601 maprow *row = self->row + (y + my);
… …
2061 if (row->c0 <= x + mx && x + mx < row->c1) 2604 if (row->c0 <= x + mx && x + mx < row->c1)
2062 { 2605 {
2063 mapcell *cell = row->col + (x + mx - row->c0); 2606 mapcell *cell = row->col + (x + mx - row->c0);
2064 2607
2065 darkness1 [y * sw1 + x] = cell->darkness 2608 darkness1 [y * sw1 + x] = cell->darkness
2066 ? 255 - (cell->darkness - 1) 2609 ? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2067 : 255 - FOW_DARKNESS; 2610 : DARKNESS_ADJUST (255 - FOW_DARKNESS);
2068 } 2611 }
2069 } 2612 }
2070 2613
2071 for (y = 0; y < sh; ++y) 2614 for (y = 0; y < sh; ++y)
2072 for (x = 0; x < sw; ++x) 2615 for (x = 0; x < sw; ++x)
… …
2091 2634
2092 uint8_t r13 = (d13 + d23 + d12) / 3; 2635 uint8_t r13 = (d13 + d23 + d12) / 3;
2093 uint8_t r23 = d23; 2636 uint8_t r23 = d23;
2094 uint8_t r33 = (d23 + d33 + d32) / 3; 2637 uint8_t r33 = (d23 + d33 + d32) / 3;
2095 2638
2096 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11); 2639 darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2097 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21); 2640 darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2098 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31); 2641 darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2099 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12); 2642 darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2100 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 */
2101 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32); 2644 darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2102 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13); 2645 darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2103 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23); 2646 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2104 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33); 2647 darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2105 } 2648 }
2106 2649
2107 free (darkness1); 2650 free (darkness1);
2108 2651
2109 EXTEND (SP, 3); 2652 EXTEND (SP, 3);
2110 PUSHs (sv_2mortal (newSViv (sw34))); 2653 PUSHs (sv_2mortal (newSViv (sw3)));
2111 PUSHs (sv_2mortal (newSViv (sh3))); 2654 PUSHs (sv_2mortal (newSViv (sh3)));
2112 PUSHs (darkness3_sv); 2655 PUSHs (darkness3_sv);
2113} 2656}
2114 2657
2115SV * 2658SV *
2116get_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)
2117 CODE: 2660 CODE:
2118{ 2661{
2119 int x, y, x1, y1; 2662 int x, y, x1, y1;
2120 SV *data_sv = newSV (w * h * 7 + 5); 2663 SV *data_sv = newSV (w * h * 7 + 5);
2121 uint8_t *data = (uint8_t *)SvPVX (data_sv); 2664 uint8_t *data = (uint8_t *)SvPVX (data_sv);
… …
2178 else 2721 else
2179 *data++ = 0; 2722 *data++ = 0;
2180 } 2723 }
2181 } 2724 }
2182 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 {
2183 SvPOK_only (data_sv); 2729 SvPOK_only (data_sv);
2184 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2730 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2731 }
2732
2185 RETVAL = data_sv; 2733 RETVAL = data_sv;
2186} 2734}
2187 OUTPUT: 2735 OUTPUT:
2188 RETVAL 2736 RETVAL
2189 2737
2190void 2738void
2191set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data) 2739set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2192 PPCODE: 2740 PPCODE:
2193{ 2741{
2194 int x, y, z; 2742 int x, y, z;
2195 int w, h; 2743 int w, h;
2196 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;
2197 2755
2198 if (*data++ != 0) 2756 if (*data++ != 0)
2199 return; /* version mismatch */ 2757 XSRETURN_EMPTY; /* version mismatch */
2200 2758
2201 w = *data++ << 8; w |= *data++; 2759 w = *data++ << 8; w |= *data++;
2202 h = *data++ << 8; h |= *data++; 2760 h = *data++ << 8; h |= *data++;
2203 2761
2204 // 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
… …
2216 { 2774 {
2217 maprow *row = map_get_row (self, y); 2775 maprow *row = map_get_row (self, y);
2218 2776
2219 for (x = x0; x < x1; x++) 2777 for (x = x0; x < x1; x++)
2220 { 2778 {
2779 uint8_t flags;
2780
2781 if (data + 7 >= end)
2782 XSRETURN_EMPTY;
2783
2221 uint8_t flags = *data++; 2784 flags = *data++;
2222 2785
2223 if (flags) 2786 if (flags)
2224 { 2787 {
2225 mapcell *cell = row_get_cell (row, x); 2788 mapcell *cell = row_get_cell (row, x);
2226 tileid tile[3] = { 0, 0, 0 }; 2789 tileid tile[3] = { 0, 0, 0 };
… …
2229 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; } 2792 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2230 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; } 2793 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2231 2794
2232 if (cell->darkness == 0) 2795 if (cell->darkness == 0)
2233 { 2796 {
2234 cell->darkness = 0; 2797 /*cell->darkness = 0;*/
2798 EXTEND (SP, 3);
2235 2799
2236 for (z = 0; z <= 2; z++) 2800 for (z = 0; z <= 2; z++)
2237 { 2801 {
2238 tileid t = tile [z]; 2802 tileid t = tile [z];
2239 2803
2240 if (t >= self->texs || (t && !self->tex [t].name)) 2804 if (t >= self->texs || (t && !self->tex [t].name))
2241 { 2805 {
2242 XPUSHs (sv_2mortal (newSViv (t))); 2806 PUSHs (sv_2mortal (newSViv (t)));
2243 need_texid (self, t); 2807 need_texid (self, t);
2244 } 2808 }
2245 2809
2246 cell->tile [z] = t; 2810 cell->tile [z] = t;
2247 } 2811 }
… …
2249 } 2813 }
2250 } 2814 }
2251 } 2815 }
2252} 2816}
2253 2817
2254MODULE = CFPlus PACKAGE = CFPlus::RW 2818MODULE = Deliantra::Client PACKAGE = DC::RW
2255 2819
2256CFPlus::RW 2820DC::RW
2257new (SV *class, SV *data_sv) 2821new (SV *klass, SV *data_sv)
2258 CODE: 2822 CODE:
2259{ 2823{
2260 STRLEN datalen; 2824 STRLEN datalen;
2261 char *data = SvPVbyte (data_sv, datalen); 2825 char *data = SvPVbyte (data_sv, datalen);
2262 2826
2263 RETVAL = SDL_RWFromConstMem (data, datalen); 2827 RETVAL = SDL_RWFromConstMem (data, datalen);
2264} 2828}
2265 OUTPUT: 2829 OUTPUT:
2266 RETVAL 2830 RETVAL
2267 2831
2268CFPlus::RW 2832DC::RW
2269new_from_file (SV *class, const char *path, const char *mode = "rb") 2833new_from_file (SV *klass, const char *path, const char *mode = "rb")
2270 CODE: 2834 CODE:
2271 RETVAL = SDL_RWFromFile (path, mode); 2835 RETVAL = SDL_RWFromFile (path, mode);
2272 OUTPUT: 2836 OUTPUT:
2273 RETVAL 2837 RETVAL
2274 2838
2275# fails on win32: 2839# fails on win32:
2276# CFPlus.xs(2268) : error C2059: syntax error : '(' 2840# dc.xs(2268) : error C2059: syntax error : '('
2277#void 2841#void
2278#close (CFPlus::RW self) 2842#close (DC::RW self)
2279# CODE: 2843# CODE:
2280# (self->(close)) (self); 2844# (self->(close)) (self);
2281 2845
2282MODULE = CFPlus PACKAGE = CFPlus::Channel 2846MODULE = Deliantra::Client PACKAGE = DC::Channel
2283 2847
2284PROTOTYPES: DISABLE 2848PROTOTYPES: DISABLE
2285 2849
2286CFPlus::Channel 2850DC::Channel
2287find () 2851find ()
2288 CODE: 2852 CODE:
2289{ 2853{
2290 RETVAL = Mix_GroupAvailable (-1); 2854 RETVAL = Mix_GroupAvailable (-1);
2291 2855
2292 if (RETVAL < 0) 2856 if (RETVAL < 0)
2293 { 2857 {
2294 RETVAL = Mix_GroupOldest (-1); 2858 RETVAL = Mix_GroupOldest (-1);
2295 2859
2296 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)
2297 XSRETURN_UNDEF; 2866 XSRETURN_UNDEF;
2298 2867 }
2868 else
2299 Mix_HaltChannel (RETVAL); 2869 Mix_HaltChannel (RETVAL);
2300 } 2870 }
2301 2871
2302 Mix_UnregisterAllEffects (RETVAL); 2872 Mix_UnregisterAllEffects (RETVAL);
2303 Mix_Volume (RETVAL, 128); 2873 Mix_Volume (RETVAL, 128);
2304} 2874}
2305 OUTPUT: 2875 OUTPUT:
2306 RETVAL 2876 RETVAL
2307 2877
2308void 2878void
2309halt (CFPlus::Channel self) 2879halt (DC::Channel self)
2310 CODE: 2880 CODE:
2311 Mix_HaltChannel (self); 2881 Mix_HaltChannel (self);
2312 2882
2313void 2883void
2314expire (CFPlus::Channel self, int ticks = -1) 2884expire (DC::Channel self, int ticks = -1)
2315 CODE: 2885 CODE:
2316 Mix_ExpireChannel (self, ticks); 2886 Mix_ExpireChannel (self, ticks);
2317 2887
2318void 2888void
2319fade_out (CFPlus::Channel self, int ticks = -1) 2889fade_out (DC::Channel self, int ticks = -1)
2320 CODE: 2890 CODE:
2321 Mix_FadeOutChannel (self, ticks); 2891 Mix_FadeOutChannel (self, ticks);
2322 2892
2323int 2893int
2324volume (CFPlus::Channel self, int volume) 2894volume (DC::Channel self, int volume)
2325 CODE: 2895 CODE:
2326 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128)); 2896 RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2327 OUTPUT: 2897 OUTPUT:
2328 RETVAL 2898 RETVAL
2329 2899
2330void 2900void
2331unregister_all_effects (CFPlus::Channel self) 2901unregister_all_effects (DC::Channel self)
2332 CODE: 2902 CODE:
2333 Mix_UnregisterAllEffects (self); 2903 Mix_UnregisterAllEffects (self);
2334 2904
2335void 2905void
2336set_panning (CFPlus::Channel self, int left, int right) 2906set_panning (DC::Channel self, int left, int right)
2337 CODE: 2907 CODE:
2338 left = CLAMP (left , 0, 255); 2908 left = CLAMP (left , 0, 255);
2339 right = CLAMP (right, 0, 255); 2909 right = CLAMP (right, 0, 255);
2340 Mix_SetPanning (self, left, right); 2910 Mix_SetPanning (self, left, right);
2341 2911
2342void 2912void
2343set_distance (CFPlus::Channel self, int distance) 2913set_distance (DC::Channel self, int distance)
2344 CODE: 2914 CODE:
2345 Mix_SetDistance (self, CLAMP (distance, 0, 255)); 2915 Mix_SetDistance (self, CLAMP (distance, 0, 255));
2346 2916
2347void 2917void
2348set_position (CFPlus::Channel self, int angle, int distance) 2918set_position (DC::Channel self, int angle, int distance)
2349 CODE: 2919 CODE:
2350 2920
2351void 2921void
2352set_position_r (CFPlus::Channel self, int dx, int dy, int maxdistance) 2922set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2353 CODE: 2923 CODE:
2354{ 2924{
2355 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance)); 2925 int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2356 int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI); 2926 int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2357 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255)); 2927 Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2358} 2928}
2359 2929
2360void 2930void
2361set_reverse_stereo (CFPlus::Channel self, int flip) 2931set_reverse_stereo (DC::Channel self, int flip)
2362 CODE: 2932 CODE:
2363 Mix_SetReverseStereo (self, flip); 2933 Mix_SetReverseStereo (self, flip);
2364 2934
2365MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2935MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2366 2936
2367PROTOTYPES: DISABLE 2937PROTOTYPES: DISABLE
2368 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
2369CFPlus::MixChunk 2951DC::MixChunk
2370new (SV *class, CFPlus::RW rwops) 2952new (SV *klass, DC::RW rwops)
2371 CODE: 2953 CODE:
2372 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2954 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2373 OUTPUT: 2955 OUTPUT:
2374 RETVAL 2956 RETVAL
2375 2957
2376void 2958void
2377DESTROY (CFPlus::MixChunk self) 2959DESTROY (DC::MixChunk self)
2378 CODE: 2960 CODE:
2379 Mix_FreeChunk (self); 2961 Mix_FreeChunk (self);
2380 2962
2381int 2963int
2382volume (CFPlus::MixChunk self, int volume = -1) 2964volume (DC::MixChunk self, int volume = -1)
2383 CODE: 2965 CODE:
2384 if (items > 1) 2966 if (items > 1)
2385 volume = CLAMP (volume, 0, 128); 2967 volume = CLAMP (volume, 0, 128);
2386 RETVAL = Mix_VolumeChunk (self, volume); 2968 RETVAL = Mix_VolumeChunk (self, volume);
2387 OUTPUT: 2969 OUTPUT:
2388 RETVAL 2970 RETVAL
2389 2971
2390CFPlus::Channel 2972DC::Channel
2391play (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)
2392 CODE: 2974 CODE:
2393{ 2975{
2394 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks); 2976 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2395 2977
2396 if (RETVAL < 0) 2978 if (RETVAL < 0)
… …
2403 } 2985 }
2404} 2986}
2405 OUTPUT: 2987 OUTPUT:
2406 RETVAL 2988 RETVAL
2407 2989
2408MODULE = 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
2409 3003
2410int 3004int
2411volume (int volume = -1) 3005volume (int volume = -1)
2412 PROTOTYPE: ;$ 3006 PROTOTYPE: ;$
2413 CODE: 3007 CODE:
… …
2425void 3019void
2426halt () 3020halt ()
2427 CODE: 3021 CODE:
2428 Mix_HaltMusic (); 3022 Mix_HaltMusic ();
2429 3023
3024int
3025playing ()
3026 CODE:
3027 RETVAL = Mix_PlayingMusic ();
3028 OUTPUT:
3029 RETVAL
3030
2430CFPlus::MixMusic 3031DC::MixMusic
2431new (SV *class, CFPlus::RW rwops) 3032new (SV *klass, DC::RW rwops)
2432 CODE: 3033 CODE:
2433 RETVAL = Mix_LoadMUS_RW (rwops); 3034 RETVAL = Mix_LoadMUS_RW (rwops);
2434 OUTPUT: 3035 OUTPUT:
2435 RETVAL 3036 RETVAL
2436 3037
2437void 3038void
2438DESTROY (CFPlus::MixMusic self) 3039DESTROY (DC::MixMusic self)
2439 CODE: 3040 CODE:
2440 Mix_FreeMusic (self); 3041 Mix_FreeMusic (self);
2441 3042
2442int 3043int
2443play (CFPlus::MixMusic self, int loops = -1) 3044play (DC::MixMusic self, int loops = -1)
2444 CODE: 3045 CODE:
2445 RETVAL = Mix_PlayMusic (self, loops); 3046 RETVAL = Mix_PlayMusic (self, loops);
2446 OUTPUT: 3047 OUTPUT:
2447 RETVAL 3048 RETVAL
2448 3049
2449void 3050void
2450fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position) 3051fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2451 CODE: 3052 CODE:
2452 Mix_FadeInMusicPos (self, loops, ms, position); 3053 Mix_FadeInMusicPos (self, loops, ms, position);
2453 3054
2454MODULE = CFPlus PACKAGE = CFPlus::OpenGL 3055MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2455 3056
2456PROTOTYPES: ENABLE 3057PROTOTYPES: ENABLE
2457 3058
2458BOOT: 3059BOOT:
2459{ 3060{
2460 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 3061 HV *stash = gv_stashpv ("DC::OpenGL", 1);
2461 static const struct { 3062 static const struct {
2462 const char *name; 3063 const char *name;
2463 IV iv; 3064 IV iv;
2464 } *civ, const_iv[] = { 3065 } *civ, const_iv[] = {
2465# define const_iv(name) { # name, (IV)name } 3066# define const_iv(name) { # name, (IV)name }
2466 const_iv (GL_VENDOR), 3067 const_iv (GL_VENDOR),
2467 const_iv (GL_VERSION), 3068 const_iv (GL_VERSION),
2468 const_iv (GL_EXTENSIONS), 3069 const_iv (GL_EXTENSIONS),
3070 const_iv (GL_MAX_TEXTURE_UNITS),
2469 const_iv (GL_COLOR_MATERIAL), 3071 const_iv (GL_COLOR_MATERIAL),
2470 const_iv (GL_SMOOTH), 3072 const_iv (GL_SMOOTH),
2471 const_iv (GL_FLAT), 3073 const_iv (GL_FLAT),
2472 const_iv (GL_DITHER), 3074 const_iv (GL_DITHER),
2473 const_iv (GL_BLEND), 3075 const_iv (GL_BLEND),
… …
2485 const_iv (GL_ZERO), 3087 const_iv (GL_ZERO),
2486 const_iv (GL_SRC_ALPHA), 3088 const_iv (GL_SRC_ALPHA),
2487 const_iv (GL_DST_ALPHA), 3089 const_iv (GL_DST_ALPHA),
2488 const_iv (GL_ONE_MINUS_SRC_ALPHA), 3090 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2489 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),
2490 const_iv (GL_SRC_ALPHA_SATURATE), 3096 const_iv (GL_SRC_ALPHA_SATURATE),
2491 const_iv (GL_RGB), 3097 const_iv (GL_RGB),
2492 const_iv (GL_RGBA), 3098 const_iv (GL_RGBA),
2493 const_iv (GL_RGBA4), 3099 const_iv (GL_RGBA4),
2494 const_iv (GL_RGBA8), 3100 const_iv (GL_RGBA8),
… …
2500 const_iv (GL_INTENSITY), 3106 const_iv (GL_INTENSITY),
2501 const_iv (GL_LUMINANCE), 3107 const_iv (GL_LUMINANCE),
2502 const_iv (GL_LUMINANCE_ALPHA), 3108 const_iv (GL_LUMINANCE_ALPHA),
2503 const_iv (GL_FLOAT), 3109 const_iv (GL_FLOAT),
2504 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),
2505 const_iv (GL_COMPILE), 3117 const_iv (GL_COMPILE),
2506 const_iv (GL_PROXY_TEXTURE_1D), 3118 const_iv (GL_PROXY_TEXTURE_1D),
2507 const_iv (GL_PROXY_TEXTURE_2D), 3119 const_iv (GL_PROXY_TEXTURE_2D),
2508 const_iv (GL_TEXTURE_1D), 3120 const_iv (GL_TEXTURE_1D),
2509 const_iv (GL_TEXTURE_2D), 3121 const_iv (GL_TEXTURE_2D),
… …
2548 const_iv (GL_PERSPECTIVE_CORRECTION_HINT), 3160 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2549 const_iv (GL_POINT_SMOOTH_HINT), 3161 const_iv (GL_POINT_SMOOTH_HINT),
2550 const_iv (GL_LINE_SMOOTH_HINT), 3162 const_iv (GL_LINE_SMOOTH_HINT),
2551 const_iv (GL_POLYGON_SMOOTH_HINT), 3163 const_iv (GL_POLYGON_SMOOTH_HINT),
2552 const_iv (GL_GENERATE_MIPMAP_HINT), 3164 const_iv (GL_GENERATE_MIPMAP_HINT),
3165 const_iv (GL_TEXTURE_COMPRESSION_HINT),
2553 const_iv (GL_FASTEST), 3166 const_iv (GL_FASTEST),
2554 const_iv (GL_DONT_CARE), 3167 const_iv (GL_DONT_CARE),
2555 const_iv (GL_NICEST), 3168 const_iv (GL_NICEST),
2556 const_iv (GL_V2F), 3169 const_iv (GL_V2F),
2557 const_iv (GL_V3F), 3170 const_iv (GL_V3F),
2558 const_iv (GL_T2F_V3F), 3171 const_iv (GL_T2F_V3F),
2559 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),
2560# undef const_iv 3176# undef const_iv
2561 }; 3177 };
2562 3178
2563 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--)
2564 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3180 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2565 3181
2566 texture_av = newAV (); 3182 texture_av = newAV ();
2567 AvREAL_off (texture_av); 3183 AvREAL_off (texture_av);
2568} 3184}
2569 3185
2570char * 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 *
2571gl_vendor () 3196gl_vendor ()
2572 CODE: 3197 CODE:
2573 RETVAL = (char *)glGetString (GL_VENDOR); 3198 RETVAL = (const char *)glGetString (GL_VENDOR);
2574 OUTPUT: 3199 OUTPUT:
2575 RETVAL 3200 RETVAL
2576 3201
2577char * 3202const char *
2578gl_version () 3203gl_version ()
2579 CODE: 3204 CODE:
2580 RETVAL = (char *)glGetString (GL_VERSION); 3205 RETVAL = (const char *)glGetString (GL_VERSION);
2581 OUTPUT: 3206 OUTPUT:
2582 RETVAL 3207 RETVAL
2583 3208
2584char * 3209const char *
2585gl_extensions () 3210gl_extensions ()
2586 CODE: 3211 CODE:
2587 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3212 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2588 OUTPUT: 3213 OUTPUT:
2589 RETVAL 3214 RETVAL
2590 3215
2591const char *glGetString (GLenum pname) 3216const char *glGetString (GLenum pname)
3217 CODE:
3218 RETVAL = (const char *)glGetString (pname);
3219 OUTPUT:
3220 RETVAL
2592 3221
2593GLint glGetInteger (GLenum pname) 3222GLint glGetInteger (GLenum pname)
2594 CODE: 3223 CODE:
2595 glGetIntegerv (pname, &RETVAL); 3224 glGetIntegerv (pname, &RETVAL);
2596 OUTPUT: 3225 OUTPUT:
… …
2604 3233
2605int glGetError () 3234int glGetError ()
2606 3235
2607void glFinish () 3236void glFinish ()
2608 3237
3238void glFlush ()
3239
2609void glClear (int mask) 3240void glClear (int mask)
2610 3241
2611void glClearColor (float r, float g, float b, float a = 1.0) 3242void glClearColor (float r, float g, float b, float a = 1.0)
2612 PROTOTYPE: @ 3243 PROTOTYPE: @
2613 3244
… …
2622void glBlendFunc (int sfactor, int dfactor) 3253void glBlendFunc (int sfactor, int dfactor)
2623 3254
2624void glBlendFuncSeparate (int sa, int da, int saa, int daa) 3255void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2625 CODE: 3256 CODE:
2626 gl_BlendFuncSeparate (sa, da, saa, daa); 3257 gl_BlendFuncSeparate (sa, da, saa, daa);
3258
3259# void glBlendEquation (int se)
2627 3260
2628void glDepthMask (int flag) 3261void glDepthMask (int flag)
2629 3262
2630void glLogicOp (int opcode) 3263void glLogicOp (int opcode)
2631 3264
… …
2666void glRotate (float angle, float x, float y, float z) 3299void glRotate (float angle, float x, float y, float z)
2667 CODE: 3300 CODE:
2668 glRotatef (angle, x, y, z); 3301 glRotatef (angle, x, y, z);
2669 3302
2670void 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: @
2671 ALIAS: 3305 ALIAS:
2672 glColor_premultiply = 1 3306 glColor_premultiply = 1
2673 CODE: 3307 CODE:
2674 if (ix) 3308 if (ix)
2675 { 3309 {
… …
2695 3329
2696void glRect (float x1, float y1, float x2, float y2) 3330void glRect (float x1, float y1, float x2, float y2)
2697 CODE: 3331 CODE:
2698 glRectf (x1, y1, x2, y2); 3332 glRectf (x1, y1, x2, y2);
2699 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
2700PROTOTYPES: ENABLE 3343PROTOTYPES: ENABLE
2701 3344
2702void glBegin (int mode) 3345void glBegin (int mode)
2703 3346
2704void glEnd () 3347void glEnd ()
… …
2736void 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)
2737 CODE: 3380 CODE:
2738 if (gl.SeparableFilter2D) 3381 if (gl.SeparableFilter2D)
2739 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column); 3382 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2740 3383
2741void 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)
2742 3385
2743void 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)
2744 3387
2745void glDrawPixels (int width, int height, int format, int type, char *pixels) 3388void glDrawPixels (int width, int height, int format, int type, char *pixels)
2746 3389
… …
2772 3415
2773void glEndList () 3416void glEndList ()
2774 3417
2775void glCallList (int list) 3418void glCallList (int list)
2776 3419
2777MODULE = 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
2778 3426
2779PROTOTYPES: DISABLE 3427PROTOTYPES: DISABLE
2780 3428
2781void 3429void
2782find_widget (SV *self, NV x, NV y) 3430find_widget (SV *self, NV x, NV y)
2783 PPCODE: 3431 PPCODE:
2784{ 3432{
2785 if (within_widget (self, x, y)) 3433 if (within_widget (self, x, y))
2786 XPUSHs (self); 3434 XPUSHs (self);
2787} 3435}
2788 3436
2789BOOT: 3437BOOT:
2790{ 3438{
2791 hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV); 3439 hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
2792 3440
2793 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);
2794 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);
2795 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);
2796 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);
2797} 3445}
2798 3446
2799void 3447void
2800draw (SV *self) 3448draw (SV *self)
2801 CODE: 3449 CODE:
2802{ 3450{
2803 HV *hv; 3451 HV *hv;
2804 SV **svp; 3452 SV **svp;
2805 NV x, y, w, h; 3453 NV x, y, w, h;
2806 SV *draw_x_sv = GvSV (draw_x_gv); 3454 SV *draw_x_sv = GvSV (draw_x_gv);
2807 SV *draw_y_sv = GvSV (draw_y_gv); 3455 SV *draw_y_sv = GvSV (draw_y_gv);
2808 SV *draw_w_sv = GvSV (draw_w_gv); 3456 SV *draw_w_sv = GvSV (draw_w_gv);
2809 SV *draw_h_sv = GvSV (draw_h_gv); 3457 SV *draw_h_sv = GvSV (draw_h_gv);
2810 SV *hover;
2811 double draw_x, draw_y, draw_w, draw_h; 3458 double draw_x, draw_y;
2812 3459
2813 if (!SvROK (self)) 3460 if (!SvROK (self))
2814 croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self)); 3461 croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
2815 3462
2816 hv = (HV *)SvRV (self); 3463 hv = (HV *)SvRV (self);
2817 3464
2818 if (SvTYPE (hv) != SVt_PVHV) 3465 if (SvTYPE (hv) != SVt_PVHV)
2819 croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self)); 3466 croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
2820 3467
2821 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.;
2822 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.;
2823 3470
2824 if (!h || !w) 3471 if (!h || !w)
… …
2844 { 3491 {
2845 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0); 3492 svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2846 3493
2847 if (svp && SvTRUE (*svp)) 3494 if (svp && SvTRUE (*svp))
2848 { 3495 {
2849 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);
2850 glEnable (GL_BLEND); 3497 glEnable (GL_BLEND);
2851 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA); 3498 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2852 glBegin (GL_QUADS); 3499 glBegin (GL_QUADS);
2853 glVertex2f (0, 0); 3500 glVertex2f (0, 0);
2854 glVertex2f (w, 0); 3501 glVertex2f (w, 0);
… …
2857 glEnd (); 3504 glEnd ();
2858 glDisable (GL_BLEND); 3505 glDisable (GL_BLEND);
2859 } 3506 }
2860 } 3507 }
2861#if 0 3508#if 0
2862 if ($ENV{CFPLUS_DEBUG} & 1) { 3509 // draw borders, for debugging
2863 glPushMatrix; 3510 glPushMatrix ();
2864 glColor 1, 1, 0, 1; 3511 glColor4f (1., 1., 0., 1.);
2865 glTranslate 0.375, 0.375; 3512 glTranslatef (.5, .5, 0.);
2866 glBegin GL_LINE_LOOP; 3513 glBegin (GL_LINE_LOOP);
2867 glVertex 0 , 0; 3514 glVertex2f (0 , 0);
2868 glVertex $self->{w} - 1, 0; 3515 glVertex2f (w - 1, 0);
2869 glVertex $self->{w} - 1, $self->{h} - 1; 3516 glVertex2f (w - 1, h - 1);
2870 glVertex 0 , $self->{h} - 1; 3517 glVertex2f (0 , h - 1);
2871 glEnd; 3518 glEnd ();
2872 glPopMatrix; 3519 glPopMatrix ();
2873 #CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2874 }
2875#endif 3520#endif
2876 PUSHMARK (SP); 3521 PUSHMARK (SP);
2877 XPUSHs (self); 3522 XPUSHs (self);
2878 PUTBACK; 3523 PUTBACK;
2879 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