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.39 by root, Sat Apr 15 00:04:58 2006 UTC vs.
Revision 1.63 by root, Mon Apr 24 06:05:33 2006 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines