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.123 by root, Wed Jun 28 23:41:11 2006 UTC vs.
Revision 1.323 by root, Sun Nov 18 01:48:39 2018 UTC

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

Diff Legend

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