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.29 by root, Thu Apr 13 01:55:38 2006 UTC vs.
Revision 1.82 by root, Mon May 15 00:15:08 2006 UTC

1#ifdef _WIN32
2# define _WIN32_WINNT 0x0500 // needed to get win2000 api calls
3# include <malloc.h>
4# include <windows.h>
5# pragma warning(disable:4244)
6#endif
7
1#include "EXTERN.h" 8#include "EXTERN.h"
2#include "perl.h" 9#include "perl.h"
3#include "XSUB.h" 10#include "XSUB.h"
4 11
12#include <math.h>
5#include <string.h> 13#include <string.h>
6#include <stdio.h> 14#include <stdio.h>
7 15
8#include <SDL.h> 16#include <SDL.h>
17#include <SDL_endian.h>
9#include <SDL_image.h> 18#include <SDL_image.h>
19#include <SDL_mixer.h>
10#include <SDL_opengl.h> 20#include <SDL_opengl.h>
21
22#include <glib/gmacros.h>
11 23
12#include <pango/pango.h> 24#include <pango/pango.h>
13#include <pango/pangofc-fontmap.h> 25#include <pango/pangofc-fontmap.h>
14#include <pango/pangoft2.h> 26#include <pango/pangoft2.h>
27#include <pango/pangocairo.h>
15 28
29#ifndef _WIN32
16#include <sys/types.h> 30# include <sys/types.h>
17#include <sys/socket.h> 31# include <sys/socket.h>
18#include <netinet/in.h> 32# include <netinet/in.h>
19#include <netinet/tcp.h> 33# include <netinet/tcp.h>
20
21#include <inttypes.h> 34# include <inttypes.h>
35#else
36 typedef unsigned char uint8_t;
37 typedef unsigned short uint16_t;
38 typedef unsigned int uint32_t;
39 typedef signed char int8_t;
40 typedef signed short int16_t;
41 typedef signed int int32_t;
42#endif
43
44#include "glext.h"
22 45
23#define FOW_DARKNESS 32 46#define FOW_DARKNESS 32
24 47
25#define MAP_EXTEND_X 32 48#define MAP_EXTEND_X 32
26#define MAP_EXTEND_Y 512 49#define MAP_EXTEND_Y 512
27 50
28static PangoContext *context; 51#define MIN_FONT_HEIGHT 10
29static PangoFontMap *fontmap; 52
53#define GL_CALL(type,func,args) \
54 { \
55 static int init_; \
56 static type fptr_; \
57 \
58 if (!init_) \
59 { \
60 init_ = 1; \
61 fptr_ = (type)SDL_GL_GetProcAddress (# func); \
62 } \
63 \
64 if (fptr_) \
65 fptr_ args; \
66 }
67
68typedef Mix_Chunk *CFClient__MixChunk;
69typedef Mix_Music *CFClient__MixMusic;
70
71typedef PangoFontDescription *CFClient__Font;
30 72
31typedef struct cf_layout { 73typedef struct cf_layout {
32 PangoLayout *pl; 74 PangoLayout *pl; // either derived from a cairo or ft2 context
75 int rgba; // wether we use rgba (cairo) or grayscale (ft2)
76 float r, g, b, a; // default color for rgba mode
33 int base_height; 77 int base_height;
78 CFClient__Font font;
34} *CFClient__Layout; 79} *CFClient__Layout;
80
81static CFClient__Font default_font;
82static PangoContext *ft2_context, *cairo_context;
83static PangoFontMap *ft2_fontmap, *cairo_fontmap;
35 84
36static void 85static void
37substitute_func (FcPattern *pattern, gpointer data) 86substitute_func (FcPattern *pattern, gpointer data)
38{ 87{
39 FcPatternAddBool (pattern, FC_HINTING , 1); 88 FcPatternAddBool (pattern, FC_HINTING , 1);
89#ifndef _WIN32
40 FcPatternAddBool (pattern, FC_AUTOHINT, 1); 90 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
91#endif
41} 92}
42 93
43static void 94static void
44layout_update (CFClient__Layout self) 95layout_update_font (CFClient__Layout self)
45{ 96{
46 /* use a random scale factor to account for unknown descenders, 0.8 works 97 /* use a random scale factor to account for unknown descenders, 0.8 works
47 * reasonably well with bitstream vera 98 * reasonably well with bitstream vera
48 */ 99 */
49 PangoFontDescription *font = pango_context_get_font_description (context); 100 PangoFontDescription *font = self->font ? self->font : default_font;
50 pango_font_description_set_absolute_size (font, self->base_height * (PANGO_SCALE * 8 / 10)); 101
102 pango_font_description_set_absolute_size (font,
103 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
104
105 pango_layout_set_font_description (self->pl, font);
51} 106}
52 107
53static void 108static void
54layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 109layout_get_pixel_size (CFClient__Layout self, int *w, int *h)
55{ 110{
56 layout_update (self);
57
58 pango_layout_get_pixel_size (self->pl, w, h); 111 pango_layout_get_pixel_size (self->pl, w, h);
59 112
60 *w = (*w + 3) & ~3;
61 if (!*w) *w = 1; 113 if (!*w) *w = 1;
62 if (!*h) *h = 1; 114 if (!*h) *h = 1;
115
116 *w = (*w + 3) & ~3;
63} 117}
118
119typedef uint16_t mapface;
120
121typedef struct {
122 GLint name;
123 int w, h;
124 float s, t;
125 uint8_t r, g, b, a;
126} maptex;
64 127
65typedef struct { 128typedef struct {
66 int16_t darkness; 129 int16_t darkness;
67 uint16_t face[3]; 130 mapface face[3];
68} mapcell; 131} mapcell;
69 132
70typedef struct { 133typedef struct {
71 uint32_t c0, c1; 134 int32_t c0, c1;
72 mapcell *col; 135 mapcell *col;
73} maprow; 136} maprow;
74 137
75typedef struct map { 138typedef struct map {
76 int x, y, w, h; 139 int x, y, w, h;
140 int ox, oy; /* offset to virtual global coordinate system */
77 int faces; 141 int faces;
78 GLint *face; 142 mapface *face;
79 143
144 int texs;
145 maptex *tex;
146
80 uint32_t rows; 147 int32_t rows;
81 maprow *row; 148 maprow *row;
82} *CFClient__Map; 149} *CFClient__Map;
83 150
151static char *
152prepend (char *ptr, int sze, int inc)
153{
154 char *p;
155
156 New (0, p, sze + inc, char);
157 Zero (p, inc, char);
158 Move (ptr, p + inc, sze, char);
159 Safefree (ptr);
160
161 return p;
162}
163
164static char *
165append (char *ptr, int sze, int inc)
166{
167 Renew (ptr, sze + inc, char);
168 Zero (ptr + sze, inc, char);
169
170 return ptr;
171}
172
173#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
174#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
175
176static maprow *
177map_get_row (CFClient__Map self, int y)
178{
179 if (0 > y)
180 {
181 int extend = - y + MAP_EXTEND_Y;
182 Prepend (maprow, self->row, self->rows, extend);
183
184 self->rows += extend;
185 self->y += extend;
186 y += extend;
187 }
188 else if (y >= self->rows)
189 {
190 int extend = y - self->rows + MAP_EXTEND_Y;
191 Append (maprow, self->row, self->rows, extend);
192 self->rows += extend;
193 }
194
195 return self->row + y;
196}
197
198static mapcell *
199row_get_cell (maprow *row, int x)
200{
201 if (!row->col)
202 {
203 Newz (0, row->col, MAP_EXTEND_X, mapcell);
204 row->c0 = x - MAP_EXTEND_X / 4;
205 row->c1 = row->c0 + MAP_EXTEND_X;
206 }
207
208 if (row->c0 > x)
209 {
210 int extend = row->c0 - x + MAP_EXTEND_X;
211 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
212 row->c0 -= extend;
213 }
214 else if (x >= row->c1)
215 {
216 int extend = x - row->c1 + MAP_EXTEND_X;
217 Append (mapcell, row->col, row->c1 - row->c0, extend);
218 row->c1 += extend;
219 }
220
221 return row->col + (x - row->c0);
222}
223
224static mapcell *
225map_get_cell (CFClient__Map self, int x, int y)
226{
227 return row_get_cell (map_get_row (self, y), x);
228}
229
230static void
231map_clear (CFClient__Map self)
232{
233 int r;
234
235 for (r = 0; r < self->rows; r++)
236 Safefree (self->row[r].col);
237
238 Safefree (self->row);
239
240 self->x = 0;
241 self->y = 0;
242 self->ox = 0;
243 self->oy = 0;
244 self->row = 0;
245 self->rows = 0;
246}
247
84static void 248static void
85map_blank (CFClient__Map self, int x0, int y0, int w, int h) 249map_blank (CFClient__Map self, int x0, int y0, int w, int h)
86{ 250{
87 int x, y; 251 int x, y;
252 maprow *row;
88 253
89 for (y = y0; y < y0 + h; y++) 254 for (y = y0; y < y0 + h; y++)
255 if (y >= 0)
90 { 256 {
91 if (y >= self->rows) 257 if (y >= self->rows)
92 break; 258 break;
93 259
94 maprow *row = self->row + y; 260 row = self->row + y;
95 261
96 for (x = x0; x < x0 + w; x++) 262 for (x = x0; x < x0 + w; x++)
97 if (x >= row->c0) 263 if (x >= row->c0)
264 {
265 if (x >= row->c1)
266 break;
267
268 row->col[x - row->c0].darkness = -1;
269 }
270 }
271}
272
273static void
274music_finished (void)
275{
276 SDL_UserEvent ev;
277
278 ev.type = SDL_USEREVENT;
279 ev.code = 0;
280 ev.data1 = 0;
281 ev.data2 = 0;
282
283 SDL_PushEvent ((SDL_Event *)&ev);
284}
285
286static void
287channel_finished (int channel)
288{
289 SDL_UserEvent ev;
290
291 ev.type = SDL_USEREVENT;
292 ev.code = 1;
293 ev.data1 = (void *)(long)channel;
294 ev.data2 = 0;
295
296 SDL_PushEvent ((SDL_Event *)&ev);
297}
298
299MODULE = CFClient PACKAGE = CFClient
300
301PROTOTYPES: ENABLE
302
303BOOT:
304{
305 HV *stash = gv_stashpv ("CFClient", 1);
306 static const struct {
307 const char *name;
308 IV iv;
309 } *civ, const_iv[] = {
310# define const_iv(name) { # name, (IV)name }
311 const_iv (SDL_ACTIVEEVENT),
312 const_iv (SDL_KEYDOWN),
313 const_iv (SDL_KEYUP),
314 const_iv (SDL_MOUSEMOTION),
315 const_iv (SDL_MOUSEBUTTONDOWN),
316 const_iv (SDL_MOUSEBUTTONUP),
317 const_iv (SDL_JOYAXISMOTION),
318 const_iv (SDL_JOYBALLMOTION),
319 const_iv (SDL_JOYHATMOTION),
320 const_iv (SDL_JOYBUTTONDOWN),
321 const_iv (SDL_JOYBUTTONUP),
322 const_iv (SDL_QUIT),
323 const_iv (SDL_SYSWMEVENT),
324 const_iv (SDL_EVENT_RESERVEDA),
325 const_iv (SDL_EVENT_RESERVEDB),
326 const_iv (SDL_VIDEORESIZE),
327 const_iv (SDL_VIDEOEXPOSE),
328 const_iv (SDL_USEREVENT),
329 const_iv (SDLK_KP0),
330 const_iv (SDLK_KP1),
331 const_iv (SDLK_KP2),
332 const_iv (SDLK_KP3),
333 const_iv (SDLK_KP4),
334 const_iv (SDLK_KP5),
335 const_iv (SDLK_KP6),
336 const_iv (SDLK_KP7),
337 const_iv (SDLK_KP8),
338 const_iv (SDLK_KP9),
339 const_iv (SDLK_KP_PERIOD),
340 const_iv (SDLK_KP_DIVIDE),
341 const_iv (SDLK_KP_MULTIPLY),
342 const_iv (SDLK_KP_MINUS),
343 const_iv (SDLK_KP_PLUS),
344 const_iv (SDLK_KP_ENTER),
345 const_iv (SDLK_KP_EQUALS),
346 const_iv (SDLK_UP),
347 const_iv (SDLK_DOWN),
348 const_iv (SDLK_RIGHT),
349 const_iv (SDLK_LEFT),
350 const_iv (SDLK_INSERT),
351 const_iv (SDLK_HOME),
352 const_iv (SDLK_END),
353 const_iv (SDLK_PAGEUP),
354 const_iv (SDLK_PAGEDOWN),
355 const_iv (SDLK_F1),
356 const_iv (SDLK_F2),
357 const_iv (SDLK_F3),
358 const_iv (SDLK_F4),
359 const_iv (SDLK_F5),
360 const_iv (SDLK_F6),
361 const_iv (SDLK_F7),
362 const_iv (SDLK_F8),
363 const_iv (SDLK_F9),
364 const_iv (SDLK_F10),
365 const_iv (SDLK_F11),
366 const_iv (SDLK_F12),
367 const_iv (SDLK_F13),
368 const_iv (SDLK_F14),
369 const_iv (SDLK_F15),
370 const_iv (SDLK_NUMLOCK),
371 const_iv (SDLK_CAPSLOCK),
372 const_iv (SDLK_SCROLLOCK),
373 const_iv (SDLK_RSHIFT),
374 const_iv (SDLK_LSHIFT),
375 const_iv (SDLK_RCTRL),
376 const_iv (SDLK_LCTRL),
377 const_iv (SDLK_RALT),
378 const_iv (SDLK_LALT),
379 const_iv (SDLK_RMETA),
380 const_iv (SDLK_LMETA),
381 const_iv (SDLK_LSUPER),
382 const_iv (SDLK_RSUPER),
383 const_iv (SDLK_MODE),
384 const_iv (SDLK_COMPOSE),
385 const_iv (SDLK_HELP),
386 const_iv (SDLK_PRINT),
387 const_iv (SDLK_SYSREQ),
388 const_iv (SDLK_BREAK),
389 const_iv (SDLK_MENU),
390 const_iv (SDLK_POWER),
391 const_iv (SDLK_EURO),
392 const_iv (SDLK_UNDO),
393 const_iv (KMOD_NONE),
394 const_iv (KMOD_LSHIFT),
395 const_iv (KMOD_RSHIFT),
396 const_iv (KMOD_LCTRL),
397 const_iv (KMOD_RCTRL),
398 const_iv (KMOD_LALT),
399 const_iv (KMOD_RALT),
400 const_iv (KMOD_LMETA),
401 const_iv (KMOD_RMETA),
402 const_iv (KMOD_NUM),
403 const_iv (KMOD_CAPS),
404 const_iv (KMOD_MODE),
405 const_iv (KMOD_CTRL),
406 const_iv (KMOD_SHIFT),
407 const_iv (KMOD_ALT),
408 const_iv (KMOD_META)
409# undef const_iv
410 };
411
412 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
413 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
414}
415
416void
417pango_init ()
418 CODE:
419{
420 // delayed, so it can pick up new fonts added by AddFontResourceEx
421 ft2_fontmap = pango_ft2_font_map_new ();
422 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)ft2_fontmap, substitute_func, 0, 0);
423 ft2_context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)ft2_fontmap);
424
425 cairo_fontmap = pango_cairo_font_map_get_default ();
426 cairo_context = pango_cairo_font_map_create_context ((PangoCairoFontMap *)cairo_fontmap);
427}
428
429int
430SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO)
431
432void
433SDL_Quit ()
434
435void
436SDL_ListModes ()
437 PPCODE:
438{
439 SDL_Rect **m;
440
441 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
442 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
443 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
444 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1);
445
446 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0);
447 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
448 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0);
449 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
450
451 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
452 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
453 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0);
454
455 SDL_EnableUNICODE (1);
456 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
457
458 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
459
460 if (m && m != (SDL_Rect **)-1)
461 while (*m)
462 {
463 AV *av = newAV ();
464 av_push (av, newSViv ((*m)->w));
465 av_push (av, newSViv ((*m)->h));
466 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
467
468 ++m;
469 }
470}
471
472int
473SDL_SetVideoMode (int w, int h, int fullscreen)
474 CODE:
475 RETVAL = !!SDL_SetVideoMode (
476 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
477 );
478 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
479 OUTPUT:
480 RETVAL
481
482void
483SDL_GL_SwapBuffers ()
484
485void
486SDL_PollEvent ()
487 PPCODE:
488{
489 SDL_Event ev;
490
491 while (SDL_PollEvent (&ev))
98 { 492 {
99 if (x >= row->c1) 493 HV *hv = newHV ();
494 hv_store (hv, "type", 4, newSViv (ev.type), 0);
495
496 switch (ev.type)
497 {
498 case SDL_KEYDOWN:
499 case SDL_KEYUP:
500 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
501 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
502 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
503 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
100 break; 504 break;
101 505
102 row->col[x].darkness = -1; 506 case SDL_ACTIVEEVENT:
507 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
508 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
509 break;
510
511 case SDL_MOUSEMOTION:
512 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0);
513 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0);
514 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0);
515 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0);
516 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0);
517 break;
518
519 case SDL_MOUSEBUTTONDOWN:
520 case SDL_MOUSEBUTTONUP:
521 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
522 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
523 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
524 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
525 break;
526
527 case SDL_USEREVENT:
528 hv_store (hv, "code", 4, newSViv (ev.user.code), 0);
529 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
530 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
531 break;
532 }
533
534 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
103 } 535 }
104 }
105} 536}
106 537
107MODULE = CFClient PACKAGE = CFClient 538int
539Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048)
540 POSTCALL:
541 Mix_HookMusicFinished (music_finished);
542 Mix_ChannelFinished (channel_finished);
108 543
109PROTOTYPES: ENABLE 544void
545Mix_CloseAudio ()
110 546
111BOOT: 547int
112{ 548Mix_AllocateChannels (int numchans = -1)
113 fontmap = pango_ft2_font_map_new ();
114 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0);
115 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);
116}
117 549
118void 550void
119lowdelay (int fd, int val = 1) 551lowdelay (int fd, int val = 1)
120 CODE: 552 CODE:
553#ifndef _WIN32
121 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 554 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
555#endif
122 556
123char * 557char *
124gl_version () 558gl_version ()
125 CODE: 559 CODE:
126 RETVAL = (char *)glGetString (GL_VERSION); 560 RETVAL = (char *)glGetString (GL_VERSION);
136 570
137void 571void
138add_font (char *file) 572add_font (char *file)
139 CODE: 573 CODE:
140 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 574 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */
141 575#ifdef _WIN32
142void 576 // cairo... sigh... requires win2000
143set_font (char *file) 577 AddFontResourceEx (file, FR_PRIVATE, 0);
144 CODE: 578#endif
145{
146 int count;
147 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
148 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
149 FcPatternDestroy (pattern);
150 pango_context_set_font_description (context, font);
151}
152 579
153void 580void
154load_image_inline (SV *image_) 581load_image_inline (SV *image_)
155 ALIAS: 582 ALIAS:
156 load_image_file = 1 583 load_image_file = 1
163 SDL_RWops *rw = ix 590 SDL_RWops *rw = ix
164 ? SDL_RWFromFile (image, "r") 591 ? SDL_RWFromFile (image, "r")
165 : SDL_RWFromConstMem (image, image_len); 592 : SDL_RWFromConstMem (image, image_len);
166 593
167 if (!rw) 594 if (!rw)
168 croak ("load_image: unable to open file"); 595 croak ("load_image: %s", SDL_GetError ());
169 596
170 surface = IMG_Load_RW (rw, 1); 597 surface = IMG_Load_RW (rw, 1);
171 if (!surface) 598 if (!surface)
172 croak ("load_image: unable to read file"); 599 croak ("load_image: %s", SDL_GetError ());
173 600
174 fmt.palette = NULL; 601 fmt.palette = NULL;
175 fmt.BitsPerPixel = 32; 602 fmt.BitsPerPixel = 32;
176 fmt.BytesPerPixel = 4; 603 fmt.BytesPerPixel = 4;
604#if SDL_BYTEORDER == SDL_LIL_ENDIAN
177 fmt.Rmask = 0x000000ff; 605 fmt.Rmask = 0x000000ff;
178 fmt.Gmask = 0x0000ff00; 606 fmt.Gmask = 0x0000ff00;
179 fmt.Bmask = 0x00ff0000; 607 fmt.Bmask = 0x00ff0000;
180 fmt.Amask = 0xff000000; 608 fmt.Amask = 0xff000000;
609#else
610 fmt.Rmask = 0xff000000;
611 fmt.Gmask = 0x00ff0000;
612 fmt.Bmask = 0x0000ff00;
613 fmt.Amask = 0x000000ff;
614#endif
181 fmt.Rloss = 0; 615 fmt.Rloss = 0;
182 fmt.Gloss = 0; 616 fmt.Gloss = 0;
183 fmt.Bloss = 0; 617 fmt.Bloss = 0;
184 fmt.Aloss = 0; 618 fmt.Aloss = 0;
185 fmt.Rshift = 0; 619 fmt.Rshift = 0;
189 fmt.colorkey = 0; 623 fmt.colorkey = 0;
190 fmt.alpha = 0; 624 fmt.alpha = 0;
191 625
192 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 626 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
193 627
628 assert (surface2->pitch == surface2->w * 4);
629
194 EXTEND (SP, 5); 630 EXTEND (SP, 5);
195 PUSHs (sv_2mortal (newSViv (surface2->w))); 631 PUSHs (sv_2mortal (newSViv (surface2->w)));
196 PUSHs (sv_2mortal (newSViv (surface2->h))); 632 PUSHs (sv_2mortal (newSViv (surface2->h)));
197 SDL_LockSurface (surface2); 633 SDL_LockSurface (surface2);
198 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 634 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
199 SDL_UnlockSurface (surface2); 635 SDL_UnlockSurface (surface2);
200 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 636 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
201 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 637 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
202 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV))); 638 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
203 639
204 SDL_FreeSurface (surface); 640 SDL_FreeSurface (surface);
205 SDL_FreeSurface (surface2); 641 SDL_FreeSurface (surface2);
206} 642}
207 643
208void 644void
645average (int x, int y, uint32_t *data)
646 PPCODE:
647{
648 uint32_t r = 0, g = 0, b = 0, a = 0;
649
650 x = y = x * y;
651
652 while (x--)
653 {
654 uint32_t p = *data++;
655
656 r += (p ) & 255;
657 g += (p >> 8) & 255;
658 b += (p >> 16) & 255;
659 a += (p >> 24) & 255;
660 }
661
662 EXTEND (SP, 4);
663 PUSHs (sv_2mortal (newSViv (r / y)));
664 PUSHs (sv_2mortal (newSViv (g / y)));
665 PUSHs (sv_2mortal (newSViv (b / y)));
666 PUSHs (sv_2mortal (newSViv (a / y)));
667}
668
669void
670error (char *message)
671 CODE:
672#ifdef _WIN32
673 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
674#else
675 fprintf (stderr, "ERROR: %s\n", message);
676#endif
677
678void
209fatal (char *message) 679fatal (char *message)
210 CODE: 680 CODE:
211#ifdef WIN32 681#ifdef _WIN32
212 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 682 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
213#else 683#else
214 fprintf (stderr, "%s\n", message); 684 fprintf (stderr, "FATAL: %s\n", message);
215#endif 685#endif
216 exit (1); 686 exit (1);
217 687
688MODULE = CFClient PACKAGE = CFClient::Font
689
690CFClient::Font
691new_from_file (SV *class, char *path, int id = 0)
692 CODE:
693{
694 int count;
695 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
696 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
697 FcPatternDestroy (pattern);
698}
699 OUTPUT:
700 RETVAL
701
702void
703DESTROY (CFClient::Font self)
704 CODE:
705 pango_font_description_free (self);
706
707void
708make_default (CFClient::Font self)
709 CODE:
710 default_font = self;
711
218MODULE = CFClient PACKAGE = CFClient::Layout 712MODULE = CFClient PACKAGE = CFClient::Layout
219 713
220CFClient::Layout 714CFClient::Layout
221new (SV *class, int base_height = 10) 715new (SV *class, int rgba = 0)
222 CODE: 716 CODE:
223 New (0, RETVAL, 1, struct cf_layout); 717 New (0, RETVAL, 1, struct cf_layout);
224 RETVAL->base_height = base_height; 718
225 RETVAL->pl = pango_layout_new (context); 719 RETVAL->pl = pango_layout_new (rgba ? cairo_context : ft2_context);
720 RETVAL->rgba = rgba;
721 RETVAL->r = 1.;
722 RETVAL->g = 1.;
723 RETVAL->b = 1.;
724 RETVAL->a = 1.;
725 RETVAL->base_height = MIN_FONT_HEIGHT;
726 RETVAL->font = 0;
727
226 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 728 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
729 layout_update_font (RETVAL);
227 OUTPUT: 730 OUTPUT:
228 RETVAL 731 RETVAL
229 732
230void 733void
231DESTROY (CFClient::Layout self) 734DESTROY (CFClient::Layout self)
232 CODE: 735 CODE:
233 g_object_unref (self->pl); 736 g_object_unref (self->pl);
234 Safefree (self); 737 Safefree (self);
235 738
739int
740is_rgba (CFClient::Layout self)
741 CODE:
742 RETVAL = self->rgba;
743 OUTPUT:
744 RETVAL
745
236void 746void
237set_markup (CFClient::Layout self, SV *text_) 747set_text (CFClient::Layout self, SV *text_)
238 CODE: 748 CODE:
239{ 749{
240 STRLEN textlen; 750 STRLEN textlen;
241 char *text = SvPVutf8 (text_, textlen); 751 char *text = SvPVutf8 (text_, textlen);
242 752
753 pango_layout_set_text (self->pl, text, textlen);
754}
755
756void
757set_markup (CFClient::Layout self, SV *text_)
758 CODE:
759{
760 STRLEN textlen;
761 char *text = SvPVutf8 (text_, textlen);
762
243 pango_layout_set_markup (self->pl, text, textlen); 763 pango_layout_set_markup (self->pl, text, textlen);
244} 764}
245 765
766SV *
767get_text (CFClient::Layout self)
768 CODE:
769 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
770 SvUTF8_on (RETVAL);
771 OUTPUT:
772 RETVAL
773
774void
775set_foreground (CFClient::Layout self, float r, float g, float b, float a = 1.)
776 CODE:
777 self->r = r;
778 self->g = g;
779 self->b = b;
780 self->a = a;
781
782void
783set_font (CFClient::Layout self, CFClient::Font font = 0)
784 CODE:
785 if (self->font != font)
786 {
787 self->font = font;
788 layout_update_font (self);
789 }
790
246void 791void
247set_height (CFClient::Layout self, int base_height) 792set_height (CFClient::Layout self, int base_height)
248 CODE: 793 CODE:
794 if (self->base_height != base_height)
795 {
249 self->base_height = base_height; 796 self->base_height = base_height;
797 layout_update_font (self);
798 }
250 799
251void 800void
252set_width (CFClient::Layout self, int max_width = -1) 801set_width (CFClient::Layout self, int max_width = -1)
253 CODE: 802 CODE:
254 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 803 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
257size (CFClient::Layout self) 806size (CFClient::Layout self)
258 PPCODE: 807 PPCODE:
259{ 808{
260 int w, h; 809 int w, h;
261 810
262 layout_update (self);
263 layout_get_pixel_size (self, &w, &h); 811 layout_get_pixel_size (self, &w, &h);
264 812
265 EXTEND (SP, 2); 813 EXTEND (SP, 2);
266 PUSHs (sv_2mortal (newSViv (w))); 814 PUSHs (sv_2mortal (newSViv (w)));
267 PUSHs (sv_2mortal (newSViv (h))); 815 PUSHs (sv_2mortal (newSViv (h)));
270int 818int
271xy_to_index (CFClient::Layout self, int x, int y) 819xy_to_index (CFClient::Layout self, int x, int y)
272 CODE: 820 CODE:
273{ 821{
274 int index, trailing; 822 int index, trailing;
275
276 layout_update (self);
277 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 823 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
278
279 RETVAL = index; 824 RETVAL = index;
280} 825}
281 OUTPUT: 826 OUTPUT:
282 RETVAL 827 RETVAL
283 828
284void 829void
285cursor_pos (CFClient::Layout self, int index) 830cursor_pos (CFClient::Layout self, int index)
286 PPCODE: 831 PPCODE:
287{ 832{
288 PangoRectangle strong_pos; 833 PangoRectangle strong_pos;
289 layout_update (self);
290 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 834 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
835
291 EXTEND (SP, 3); 836 EXTEND (SP, 3);
292 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 837 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
293 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 838 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
294 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 839 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
295} 840}
298render (CFClient::Layout self) 843render (CFClient::Layout self)
299 PPCODE: 844 PPCODE:
300{ 845{
301 SV *retval; 846 SV *retval;
302 int w, h; 847 int w, h;
303 FT_Bitmap bitmap;
304 848
305 layout_update (self);
306 layout_get_pixel_size (self, &w, &h); 849 layout_get_pixel_size (self, &w, &h);
307 850
851 if (self->rgba)
852 {
853 cairo_surface_t *surface;
854 cairo_t *cairo;
855
856 retval = newSV (w * h * 4);
857 SvPOK_only (retval);
858 SvCUR_set (retval, w * h * 4);
859
860 memset (SvPVX (retval), 0, w * h * 4);
861
862 surface = cairo_image_surface_create_for_data (
863 (void*)SvPVX (retval), CAIRO_FORMAT_ARGB32, w, h, w * 4);
864 cairo = cairo_create (surface);
865 cairo_set_source_rgba (cairo, self->r, self->g, self->b, self->a);
866
867 pango_cairo_show_layout (cairo, self->pl);
868
869 cairo_destroy (cairo);
870 cairo_surface_destroy (surface);
871
872 // what a mess, and its premultiplied, too :(
873 {
874 uint32_t *p = (uint32_t *)SvPVX (retval);
875 uint32_t *e = p + w * h;
876
877 while (p < e)
878 {
879 uint32_t rgba = *p;
880 rgba = (rgba >> 24) | (rgba << 8);
881 rgba = SDL_SwapBE32 (rgba);
882 *p++ = rgba;
883 }
884 }
885
886 EXTEND (SP, 5);
887 PUSHs (sv_2mortal (newSViv (w)));
888 PUSHs (sv_2mortal (newSViv (h)));
889 PUSHs (sv_2mortal (retval));
890 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
891 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
892 }
893 else
894 {
895 FT_Bitmap bitmap;
896
308 retval = newSV (w * h); 897 retval = newSV (w * h);
309 SvPOK_only (retval); 898 SvPOK_only (retval);
310 SvCUR_set (retval, w * h); 899 SvCUR_set (retval, w * h);
311 900
312 bitmap.rows = h; 901 bitmap.rows = h;
313 bitmap.width = w; 902 bitmap.width = w;
314 bitmap.pitch = w; 903 bitmap.pitch = w;
315 bitmap.buffer = (unsigned char*)SvPVX (retval); 904 bitmap.buffer = (unsigned char*)SvPVX (retval);
316 bitmap.num_grays = 256; 905 bitmap.num_grays = 256;
317 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY; 906 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
318 907
319 memset (bitmap.buffer, 0, w * h); 908 memset (bitmap.buffer, 0, w * h);
320 909
321 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE); 910 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
322 911
323 EXTEND (SP, 3); 912 EXTEND (SP, 5);
324 PUSHs (sv_2mortal (newSViv (w))); 913 PUSHs (sv_2mortal (newSViv (w)));
325 PUSHs (sv_2mortal (newSViv (h))); 914 PUSHs (sv_2mortal (newSViv (h)));
326 PUSHs (sv_2mortal (retval)); 915 PUSHs (sv_2mortal (retval));
916 PUSHs (sv_2mortal (newSViv (GL_ALPHA)));
917 PUSHs (sv_2mortal (newSViv (GL_ALPHA)));
918 }
327} 919}
328 920
329MODULE = CFClient PACKAGE = CFClient::Texture 921MODULE = CFClient PACKAGE = CFClient::Texture
330 922
331void 923void
332draw_quad (SV *self, double x, double y, double w = 0, double h = 0) 924draw_quad (SV *self, float x, float y, float w = 0, float h = 0)
333 PROTOTYPE: $$$;$$ 925 PROTOTYPE: $$$;$$
926 ALIAS:
927 draw_quad_alpha = 1
928 draw_quad_alpha_premultiplied = 2
334 CODE: 929 CODE:
335{ 930{
336 HV *hv = (HV *)SvRV (self); 931 HV *hv = (HV *)SvRV (self);
337 double s = SvNV (*hv_fetch (hv, "s", 1, 1)); 932 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
338 double t = SvNV (*hv_fetch (hv, "t", 1, 1)); 933 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
339 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 934 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
935 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1));
340 936
341 if (items < 5) 937 if (items < 5)
342 { 938 {
343 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 939 w = SvNV (*hv_fetch (hv, "w", 1, 1));
344 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 940 h = SvNV (*hv_fetch (hv, "h", 1, 1));
345 } 941 }
346 942
943 if (ix)
944 {
945 glEnable (GL_BLEND);
946 glBlendFunc (ix == 1 ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
947 }
948
347 glBindTexture (GL_TEXTURE_2D, name); 949 glBindTexture (GL_TEXTURE_2D, name);
950
951 if (wrap_mode)
952 {
953 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
954 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
955 }
956
348 glBegin (GL_QUADS); 957 glBegin (GL_QUADS);
349 glTexCoord2d (0, 0); glVertex2d (x , y ); 958 glTexCoord2f (0, 0); glVertex2f (x , y );
350 glTexCoord2d (0, t); glVertex2d (x , y + h); 959 glTexCoord2f (0, t); glVertex2f (x , y + h);
351 glTexCoord2d (s, t); glVertex2d (x + w, y + h); 960 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
352 glTexCoord2d (s, 0); glVertex2d (x + w, y ); 961 glTexCoord2f (s, 0); glVertex2f (x + w, y );
353 glEnd (); 962 glEnd ();
963
964 if (ix)
965 glDisable (GL_BLEND);
354} 966}
355 967
356MODULE = CFClient PACKAGE = CFClient::Map 968MODULE = CFClient PACKAGE = CFClient::Map
357 969
358CFClient::Map 970CFClient::Map
359new (SV *class, int map_width, int map_height) 971new (SV *class, int map_width, int map_height)
360 CODE: 972 CODE:
361 New (0, RETVAL, 1, struct map); 973 New (0, RETVAL, 1, struct map);
362 RETVAL->x = 0; 974 RETVAL->x = 0;
363 RETVAL->y = 0; 975 RETVAL->y = 0;
364 RETVAL->w = map_width; 976 RETVAL->w = map_width;
365 RETVAL->h = map_height; 977 RETVAL->h = map_height;
978 RETVAL->ox = 0;
979 RETVAL->oy = 0;
366 RETVAL->faces = 1; 980 RETVAL->faces = 8192;
367 Newz (0, RETVAL->face, 1, GLint); 981 Newz (0, RETVAL->face, RETVAL->faces, mapface);
982 RETVAL->texs = 8192;
983 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
368 RETVAL->rows = 0; 984 RETVAL->rows = 0;
369 RETVAL->row = 0; 985 RETVAL->row = 0;
370 printf ("new map %d,%d\n", map_width, map_height);//D
371 OUTPUT: 986 OUTPUT:
372 RETVAL 987 RETVAL
373 988
374void 989void
375DESTROY (CFClient::Map self) 990DESTROY (CFClient::Map self)
376 CODE: 991 CODE:
377{ 992{
378 int r, c; 993 map_clear (self);
379
380 printf ("detroy map\n");//D
381 Safefree (self->face); 994 Safefree (self->face);
382
383 for (r = 0; r < self->rows; r++)
384 Safefree (self->row[r].col);
385
386 Safefree (self->row);
387 Safefree (self); 995 Safefree (self);
388} 996}
389 997
390void 998void
999clear (CFClient::Map self)
1000 CODE:
1001 map_clear (self);
1002
1003void
391set_face (CFClient::Map self, int facenum, int face) 1004set_face (CFClient::Map self, int face, int texid)
392 CODE: 1005 CODE:
393{ 1006{
394 while (self->faces < facenum) 1007 while (self->faces <= face)
395 { 1008 {
396 printf ("setface %d (%d) = %d\n",facenum, self->faces, face);//D
397 Renew (self->face, self->faces * 2, GLint);
398 Zero (self->face + self->faces, self->faces, GLint); 1009 Append (mapface, self->face, self->faces, self->faces);
399 self->faces *= 2; 1010 self->faces *= 2;
400 } 1011 }
401 1012
402 self->face [facenum] = face; 1013 self->face [face] = texid;
403} 1014}
1015
1016void
1017set_texture (CFClient::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1018 CODE:
1019{
1020 while (self->texs <= texid)
1021 {
1022 Append (maptex, self->tex, self->texs, self->texs);
1023 self->texs *= 2;
1024 }
1025
1026 {
1027 maptex *tex = self->tex + texid;
1028
1029 tex->name = name;
1030 tex->w = w;
1031 tex->h = h;
1032 tex->s = s;
1033 tex->t = t;
1034 tex->r = r;
1035 tex->g = g;
1036 tex->b = b;
1037 tex->a = a;
1038 }
1039}
1040
1041int
1042ox (CFClient::Map self)
1043 ALIAS:
1044 oy = 1
1045 CODE:
1046 switch (ix)
1047 {
1048 case 0: RETVAL = self->ox; break;
1049 case 1: RETVAL = self->oy; break;
1050 }
1051 OUTPUT:
1052 RETVAL
404 1053
405void 1054void
406scroll (CFClient::Map self, int dx, int dy) 1055scroll (CFClient::Map self, int dx, int dy)
407 CODE: 1056 CODE:
408{ 1057{
409 printf ("map_scroll %d,%d\n", dx, dy);//D
410 if (dx > 0) 1058 if (dx > 0)
411 map_blank (self, self->x, self->y, dx - 1, self->h); 1059 map_blank (self, self->x, self->y, dx - 1, self->h);
412 else if (dx < 0) 1060 else if (dx < 0)
413 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h); 1061 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h);
414 1062
415 if (dy > 0) 1063 if (dy > 0)
416 map_blank (self, self->x, self->y, self->w, dy - 1); 1064 map_blank (self, self->x, self->y, self->w, dy - 1);
417 else if (dy < 0) 1065 else if (dy < 0)
418 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy); 1066 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy);
419 1067
420 self->x += dx; 1068 self->ox += dx; self->x += dx;
421 self->y += dy; 1069 self->oy += dy; self->y += dy;
422 1070
423 while (self->y < 0) 1071 while (self->y < 0)
424 { 1072 {
425 maprow *row; 1073 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
426
427 New (0, row, self->rows + MAP_EXTEND_Y, maprow);
428 Move (self->row, row + MAP_EXTEND_Y, self->rows, maprow);
429 Zero (row, MAP_EXTEND_Y, maprow);
430 1074
431 self->rows += MAP_EXTEND_Y; 1075 self->rows += MAP_EXTEND_Y;
432 self->y += MAP_EXTEND_Y; 1076 self->y += MAP_EXTEND_Y;
433 self->row = row;
434 } 1077 }
435
436 if (self->x < 0)
437 {
438 int y;
439 for (y = 0; y < self->rows; y++)
440 {
441 self->row[y].c0 += self->x;
442 self->row[y].c1 += self->x;
443 }
444
445 self->x = 0;
446 }
447} 1078}
448 1079
449void 1080void
450map1a_update (CFClient::Map self, SV *data_) 1081map1a_update (CFClient::Map self, SV *data_)
451 CODE: 1082 CODE:
452{ 1083{
453 uint8_t *data = (uint8_t *)SvPVbytes_nolen (data_); 1084 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
454 uint8_t *data_end = (uint8_t *)SvEND (data_) + 1; 1085 uint8_t *data_end = (uint8_t *)SvEND (data_);
455 1086 mapcell *cell;
1087 int x, y, flags;
1088
456 while (data < data_end) 1089 while (data < data_end)
457 { 1090 {
458 int flags = (data [0] << 8) + data [1]; data += 2; 1091 flags = (data [0] << 8) + data [1]; data += 2;
1092
459 int x = ((flags >> 10) & 63) + self->x; 1093 x = ((flags >> 10) & 63) + self->x;
460 int y = ((flags >> 4) & 63) + self->y; 1094 y = ((flags >> 4) & 63) + self->y;
461 1095
462 while (y >= self->rows) 1096 cell = map_get_cell (self, x, y);
463 {
464 Renew (self->row, self->rows + MAP_EXTEND_Y, maprow);
465 Zero (self->row + self->rows, MAP_EXTEND_Y, maprow);
466
467 self->rows += MAP_EXTEND_Y;
468 }
469
470 assert (y < self->rows);//D
471
472 maprow *row = self->row + y;
473
474 if (!row->col)
475 {
476 Newz (0, row->col, MAP_EXTEND_X, mapcell);
477 row->c0 = self->x - MAP_EXTEND_X / 4;
478 row->c1 = row->c0 + MAP_EXTEND_X;
479 }
480
481 if (row->c0 > x)
482 {
483 int extend = row->c0 - x + MAP_EXTEND_X;
484 mapcell *col;
485
486 New (0, col, row->c1 - row->c0 + extend, mapcell);
487 Move (row->col, col + extend, row->c1 - row->c0, mapcell);
488 Zero (col, extend, mapcell);
489
490 row->col = col;
491 row->c0 -= extend;
492 }
493 else if (x >= row->c1)
494 {
495 int extend = x - row->c1 + MAP_EXTEND_X;
496
497 Renew (row->col, row->c1 - row->c0 + extend, mapcell);
498 Zero (row->col + row->c1 - row->c0, extend, mapcell);
499
500 row->c1 += extend;
501 }
502
503 assert (x >= row->c0);//D
504 assert (x < row->c1);//D
505 mapcell *cell = row->col + (x - row->c0);
506 1097
507 if (flags & 15) 1098 if (flags & 15)
508 { 1099 {
509 if (cell->darkness < 0) 1100 if (cell->darkness < 0)
510 { 1101 {
511 cell->darkness = 0; 1102 cell->darkness = 0;
512 cell->face [0] = 0; 1103 cell->face [0] = 0;
513 cell->face [1] = 0; 1104 cell->face [1] = 0;
514 cell->face [2] = 0; 1105 cell->face [2] = 0;
515 } 1106 }
516 1107
517 cell->darkness = flags & 8 ? *data++ : 255; 1108 cell->darkness = flags & 8 ? *data++ : 255;
1109
1110 //TODO: don't trust server data to be in-range(!)
518 1111
519 if (flags & 4) 1112 if (flags & 4)
520 { 1113 {
521 cell->face [0] = (data [0] << 8) + data [1]; data += 2; 1114 cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2;
522 } 1115 }
523 1116
524 if (flags & 2) 1117 if (flags & 2)
525 { 1118 {
526 cell->face [1] = (data [0] << 8) + data [1]; data += 2; 1119 cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2;
527 } 1120 }
528 1121
529 if (flags & 1) 1122 if (flags & 1)
530 { 1123 {
531 cell->face [2] = (data [0] << 8) + data [1]; data += 2; 1124 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
532 } 1125 }
533 } 1126 }
534 else 1127 else
535 cell->darkness = -1; 1128 cell->darkness = -1;
536 } 1129 }
537} 1130}
538 1131
1132SV *
1133mapmap (CFClient::Map self, int x0, int y0, int w, int h)
1134 CODE:
1135{
1136 int x1, x;
1137 int y1, y;
1138 int z;
1139 SV *map_sv = newSV (w * h * sizeof (uint32_t));
1140 uint32_t *map = (uint32_t *)SvPVX (map_sv);
1141
1142 SvPOK_only (map_sv);
1143 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
1144
1145 x0 += self->x; x1 = x0 + w;
1146 y0 += self->y; y1 = y0 + h;
1147
1148 for (y = y0; y < y1; y++)
1149 {
1150 maprow *row = 0 <= y && y < self->rows
1151 ? self->row + y
1152 : 0;
1153
1154 for (x = x0; x < x1; x++)
1155 {
1156 int r = 32, g = 32, b = 32, a = 192;
1157
1158 if (row && row->c0 <= x && x < row->c1)
1159 {
1160 mapcell *cell = row->col + (x - row->c0);
1161
1162 for (z = 0; z <= 0; z++)
1163 {
1164 mapface face = cell->face [z];
1165
1166 if (face)
1167 {
1168 maptex tex = self->tex [face];
1169 int a0 = 255 - tex.a;
1170 int a1 = tex.a;
1171
1172 r = (r * a0 + tex.r * a1) / 255;
1173 g = (g * a0 + tex.g * a1) / 255;
1174 b = (b * a0 + tex.b * a1) / 255;
1175 a = (a * a0 + tex.a * a1) / 255;
1176 }
1177 }
1178 }
1179
1180 *map++ = (r )
1181 | (g << 8)
1182 | (b << 16)
1183 | (a << 24);
1184 }
1185 }
1186
1187 RETVAL = map_sv;
1188}
1189 OUTPUT:
1190 RETVAL
1191
1192void
1193draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh)
1194 PPCODE:
1195{
1196 int vx, vy;
1197 int x, y, z;
1198 int last_name;
1199 mapface face;
1200 int sw4 = (sw + 3) & ~3;
1201 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));
1202 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv);
1203
1204 memset (darkness, 255, sw4 * sh);
1205 SvPOK_only (darkness_sv);
1206 SvCUR_set (darkness_sv, sw4 * sh);
1207
1208 vx = self->x + (self->w - sw) / 2 - shift_x;
1209 vy = self->y + (self->h - sh) / 2 - shift_y;
1210
1211 /*
1212 int vx = self->vx = self->w >= sw
1213 ? self->x + (self->w - sw) / 2
1214 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
1215
1216 int vy = self->vy = self->h >= sh
1217 ? self->y + (self->h - sh) / 2
1218 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
1219 */
1220
1221 glColor4ub (255, 255, 255, 255);
1222
1223 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1224 glEnable (GL_BLEND);
1225 glEnable (GL_TEXTURE_2D);
1226 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1227
1228 glBegin (GL_QUADS);
1229
1230 last_name = 0;
1231
1232 for (z = 0; z < 3; z++)
1233 for (y = 0; y < sh; y++)
1234 if (0 <= y + vy && y + vy < self->rows)
1235 {
1236 maprow *row = self->row + (y + vy);
1237
1238 for (x = 0; x < sw; x++)
1239 if (row->c0 <= x + vx && x + vx < row->c1)
1240 {
1241 mapcell *cell = row->col + (x + vx - row->c0);
1242
1243 darkness[y * sw4 + x] = cell->darkness < 0
1244 ? 255 - FOW_DARKNESS
1245 : 255 - cell->darkness;
1246
1247 face = cell->face [z];
1248
1249 if (face)
1250 {
1251 maptex tex = self->tex [face];
1252
1253 int px = (x + 1) * 32 - tex.w;
1254 int py = (y + 1) * 32 - tex.h;
1255
1256 if (last_name != tex.name)
1257 {
1258 glEnd ();
1259 last_name = tex.name;
1260 glBindTexture (GL_TEXTURE_2D, last_name);
1261 glBegin (GL_QUADS);
1262 }
1263
1264 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1265 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1266 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1267 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1268 }
1269 }
1270 }
1271
1272 glEnd ();
1273
1274 glDisable (GL_TEXTURE_2D);
1275 glDisable (GL_BLEND);
1276
1277 EXTEND (SP, 3);
1278 PUSHs (sv_2mortal (newSViv (sw4)));
1279 PUSHs (sv_2mortal (newSViv (sh)));
1280 PUSHs (darkness_sv);
1281}
1282
1283SV *
1284get_rect (CFClient::Map self, int x0, int y0, int w, int h)
1285 CODE:
1286{
1287 int x, y, x1, y1;
1288 SV *data_sv = newSV (w * h * 7 + 5);
1289 uint8_t *data = (uint8_t *)SvPVX (data_sv);
1290
1291 *data++ = 0; /* version 0 format */
1292 *data++ = w >> 8; *data++ = w;
1293 *data++ = h >> 8; *data++ = h;
1294
1295 // we need to do this 'cause we don't keep an absolute coord system for rows
1296 // TODO: treat rows as we treat columns
1297 map_get_row (self, y0 + self->y - self->oy);//D
1298 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
1299
1300 x0 += self->x - self->ox;
1301 y0 += self->y - self->oy;
1302
1303 x1 = x0 + w;
1304 y1 = y0 + h;
1305
1306 for (y = y0; y < y1; y++)
1307 {
1308 maprow *row = 0 <= y && y < self->rows
1309 ? self->row + y
1310 : 0;
1311
1312 for (x = x0; x < x1; x++)
1313 {
1314 if (row && row->c0 <= x && x < row->c1)
1315 {
1316 mapcell *cell = row->col + (x - row->c0);
1317 uint8_t flags = 0;
1318
1319 if (cell->face [0]) flags |= 1;
1320 if (cell->face [1]) flags |= 2;
1321 if (cell->face [2]) flags |= 4;
1322
1323 *data++ = flags;
1324
1325 if (flags & 1)
1326 {
1327 *data++ = cell->face [0] >> 8;
1328 *data++ = cell->face [0];
1329 }
1330
1331 if (flags & 2)
1332 {
1333 *data++ = cell->face [1] >> 8;
1334 *data++ = cell->face [1];
1335 }
1336
1337 if (flags & 4)
1338 {
1339 *data++ = cell->face [2] >> 8;
1340 *data++ = cell->face [2];
1341 }
1342 }
1343 else
1344 *data++ = 0;
1345 }
1346 }
1347
1348 SvPOK_only (data_sv);
1349 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
1350 RETVAL = data_sv;
1351}
1352 OUTPUT:
1353 RETVAL
1354
1355void
1356set_rect (CFClient::Map self, int x0, int y0, uint8_t *data)
1357 PPCODE:
1358{
1359 int x, y, z;
1360 int w, h;
1361 int x1, y1;
1362
1363 if (*data++ != 0)
1364 return; /* version mismatch */
1365
1366 w = *data++ << 8; w |= *data++;
1367 h = *data++ << 8; h |= *data++;
1368
1369 // we need to do this 'cause we don't keep an absolute coord system for rows
1370 // TODO: treat rows as we treat columns
1371 map_get_row (self, y0 + self->y - self->oy);//D
1372 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
1373
1374 x0 += self->x - self->ox;
1375 y0 += self->y - self->oy;
1376
1377 x1 = x0 + w;
1378 y1 = y0 + h;
1379
1380 for (y = y0; y < y1; y++)
1381 {
1382 maprow *row = map_get_row (self, y);
1383
1384 for (x = x0; x < x1; x++)
1385 {
1386 uint8_t flags = *data++;
1387
1388 if (flags)
1389 {
1390 mapface face[3] = { 0, 0, 0 };
1391
1392 mapcell *cell = row_get_cell (row, x);
1393
1394 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; }
1395 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; }
1396 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; }
1397
1398 if (cell->darkness <= 0)
1399 {
1400 cell->darkness = -1;
1401
1402 for (z = 0; z <= 2; z++)
1403 {
1404 cell->face[z] = face[z];
1405
1406 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name))
1407 XPUSHs (sv_2mortal (newSViv (face[z])));
1408 }
1409 }
1410 }
1411 }
1412 }
1413}
1414
1415MODULE = CFClient PACKAGE = CFClient::MixChunk
1416
1417CFClient::MixChunk
1418new_from_file (SV *class, char *path)
1419 CODE:
1420 RETVAL = Mix_LoadWAV (path);
1421 OUTPUT:
1422 RETVAL
1423
1424void
1425DESTROY (CFClient::MixChunk self)
1426 CODE:
1427 Mix_FreeChunk (self);
1428
1429int
1430volume (CFClient::MixChunk self, int volume = -1)
1431 CODE:
1432 RETVAL = Mix_VolumeChunk (self, volume);
1433 OUTPUT:
1434 RETVAL
1435
1436int
1437play (CFClient::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
1438 CODE:
1439 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
1440 OUTPUT:
1441 RETVAL
1442
1443MODULE = CFClient PACKAGE = CFClient::MixMusic
1444
1445int
1446volume (int volume = -1)
1447 CODE:
1448 RETVAL = Mix_VolumeMusic (volume);
1449 OUTPUT:
1450 RETVAL
1451
1452CFClient::MixMusic
1453new_from_file (SV *class, char *path)
1454 CODE:
1455 RETVAL = Mix_LoadMUS (path);
1456 OUTPUT:
1457 RETVAL
1458
1459void
1460DESTROY (CFClient::MixMusic self)
1461 CODE:
1462 Mix_FreeMusic (self);
1463
1464int
1465play (CFClient::MixMusic self, int loops = -1)
1466 CODE:
1467 RETVAL = Mix_PlayMusic (self, loops);
1468 OUTPUT:
1469 RETVAL
1470
1471MODULE = CFClient PACKAGE = CFClient::OpenGL
1472
1473BOOT:
1474{
1475 HV *stash = gv_stashpv ("CFClient::OpenGL", 1);
1476 static const struct {
1477 const char *name;
1478 IV iv;
1479 } *civ, const_iv[] = {
1480# define const_iv(name) { # name, (IV)name }
1481 const_iv (GL_COLOR_MATERIAL),
1482 const_iv (GL_SMOOTH),
1483 const_iv (GL_FLAT),
1484 const_iv (GL_DITHER),
1485 const_iv (GL_BLEND),
1486 const_iv (GL_SCISSOR_TEST),
1487 const_iv (GL_AND),
1488 const_iv (GL_ONE),
1489 const_iv (GL_ZERO),
1490 const_iv (GL_SRC_ALPHA),
1491 const_iv (GL_SRC_ALPHA_SATURATE),
1492 const_iv (GL_ONE_MINUS_SRC_ALPHA),
1493 const_iv (GL_ONE_MINUS_DST_ALPHA),
1494 const_iv (GL_RGB),
1495 const_iv (GL_RGBA),
1496 const_iv (GL_UNSIGNED_BYTE),
1497 const_iv (GL_ALPHA),
1498 const_iv (GL_LUMINANCE),
1499 const_iv (GL_FLOAT),
1500 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
1501 const_iv (GL_COMPILE),
1502 const_iv (GL_TEXTURE_1D),
1503 const_iv (GL_TEXTURE_2D),
1504 const_iv (GL_TEXTURE_ENV),
1505 const_iv (GL_TEXTURE_MAG_FILTER),
1506 const_iv (GL_TEXTURE_MIN_FILTER),
1507 const_iv (GL_TEXTURE_ENV_MODE),
1508 const_iv (GL_TEXTURE_WRAP_S),
1509 const_iv (GL_TEXTURE_WRAP_T),
1510 const_iv (GL_CLAMP),
1511 const_iv (GL_REPEAT),
1512 const_iv (GL_NEAREST),
1513 const_iv (GL_LINEAR),
1514 const_iv (GL_NEAREST_MIPMAP_NEAREST),
1515 const_iv (GL_LINEAR_MIPMAP_NEAREST),
1516 const_iv (GL_NEAREST_MIPMAP_LINEAR),
1517 const_iv (GL_LINEAR_MIPMAP_LINEAR),
1518 const_iv (GL_GENERATE_MIPMAP),
1519 const_iv (GL_MODULATE),
1520 const_iv (GL_DECAL),
1521 const_iv (GL_REPLACE),
1522 const_iv (GL_COLOR_BUFFER_BIT),
1523 const_iv (GL_PROJECTION),
1524 const_iv (GL_MODELVIEW),
1525 const_iv (GL_COLOR_LOGIC_OP),
1526 const_iv (GL_SEPARABLE_2D),
1527 const_iv (GL_CONVOLUTION_2D),
1528 const_iv (GL_CONVOLUTION_BORDER_MODE),
1529 const_iv (GL_CONSTANT_BORDER),
1530 const_iv (GL_LINES),
1531 const_iv (GL_QUADS),
1532 const_iv (GL_LINE_LOOP),
1533 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
1534 const_iv (GL_FASTEST),
1535# undef const_iv
1536 };
1537
1538 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1539 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1540}
1541
1542int glGetError ()
1543
1544void glClear (int mask)
1545
1546void glClearColor (float r, float g, float b, float a = 1.0)
1547 PROTOTYPE: @
1548
1549void glEnable (int cap)
1550
1551void glDisable (int cap)
1552
1553void glShadeModel (int mode)
1554
1555void glHint (int target, int mode)
1556
1557void glBlendFunc (int sfactor, int dfactor)
1558
1559void glLogicOp (int opcode)
1560
1561void glColorMask (int red, int green, int blue, int alpha)
1562
1563void glMatrixMode (int mode)
1564
1565void glPushMatrix ()
1566
1567void glPopMatrix ()
1568
1569void glLoadIdentity ()
1570
1571# near and far are due to microsofts buggy c compiler
1572void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
1573
1574void glViewport (int x, int y, int width, int height)
1575
1576void glScissor (int x, int y, int width, int height)
1577
1578void glTranslate (float x, float y, float z = 0.)
1579 CODE:
1580 glTranslatef (x, y, z);
1581
1582void glScale (float x, float y, float z = 1.)
1583 CODE:
1584 glScalef (x, y, z);
1585
1586void glRotate (float angle, float x, float y, float z)
1587 CODE:
1588 glRotatef (angle, x, y, z);
1589
1590void glBegin (int mode)
1591
1592void glEnd ()
1593
1594void glColor (float r, float g, float b, float a = 1.0)
1595 PROTOTYPE: @
1596 CODE:
1597 glColor4ub (MIN ((int)(r * 255.f), 255),
1598 MIN ((int)(g * 255.f), 255),
1599 MIN ((int)(b * 255.f), 255),
1600 MIN ((int)(a * 255.f), 255));
1601
1602void glVertex (float x, float y, float z = 0.)
1603 CODE:
1604 glVertex3f (x, y, z);
1605
1606void glTexCoord (float s, float t)
1607 CODE:
1608 glTexCoord2f (s, t);
1609
1610void glTexEnv (int target, int pname, float param)
1611 CODE:
1612 glTexEnvf (target, pname, param);
1613
1614void glTexParameter (int target, int pname, float param)
1615 CODE:
1616 glTexParameterf (target, pname, param);
1617
1618void glBindTexture (int target, int name)
1619
1620void glConvolutionParameter (int target, int pname, float params)
1621 CODE:
1622 GL_CALL (PFNGLCONVOLUTIONPARAMETERFEXTPROC, glConvolutionParameterf, (target, pname, params));
1623
1624void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
1625 CODE:
1626 GL_CALL (PFNGLCONVOLUTIONFILTER2DEXTPROC, glConvolutionFilter2D,
1627 (target, internalformat, width, height, format, type, data));
1628
1629void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
1630 CODE:
1631 GL_CALL (PFNGLSEPARABLEFILTER2DEXTPROC, glSeparableFilter2D,
1632 (target, internalformat, width, height, format, type, row, column));
1633
1634void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
1635
1636void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
1637
1638void glRasterPos (int x, int y)
1639 CODE:
1640 glRasterPos2i (x, y);
1641
1642void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
1643
1644int glGenTexture ()
1645 CODE:
1646{
1647 GLuint name;
1648 glGenTextures (1, &name);
1649 RETVAL = name;
1650}
1651 OUTPUT:
1652 RETVAL
1653
1654void glDeleteTexture (int name)
1655 CODE:
1656{
1657 GLuint name_ = name;
1658 glDeleteTextures (1, &name_);
1659}
1660
1661int glGenList ()
1662 CODE:
1663 RETVAL = glGenLists (1);
1664 OUTPUT:
1665 RETVAL
1666
1667void glDeleteList (int list)
1668 CODE:
1669 glDeleteLists (list, 1);
1670
1671void glNewList (int list, int mode = GL_COMPILE)
1672
1673void glEndList ()
1674
1675void glCallList (int list)
1676

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines