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.192 by root, Fri Apr 27 21:27:51 2007 UTC vs.
Revision 1.331 by root, Mon Nov 19 00:10:34 2018 UTC

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

Diff Legend

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