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.13 by root, Tue Apr 11 12:27:51 2006 UTC vs.
Revision 1.140 by root, Mon Aug 14 03:41:25 2006 UTC

1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN
3# define _WIN32_WINNT 0x0500 // needed to get win2000 api calls
4# include <malloc.h>
5# include <windows.h>
6# pragma warning(disable:4244)
7#endif
8
1#include "EXTERN.h" 9#include "EXTERN.h"
2#include "perl.h" 10#include "perl.h"
3#include "XSUB.h" 11#include "XSUB.h"
4 12
13#ifdef _WIN32
14# undef pipe
15#endif
16
17#include <math.h>
5#include <string.h> 18#include <string.h>
19#include <stdio.h>
20#include <stdlib.h>
6 21
7#include <SDL.h> 22#include <SDL.h>
23#include <SDL_endian.h>
24#include <SDL_image.h>
25#include <SDL_mixer.h>
8#include <SDL_opengl.h> 26#include <SDL_opengl.h>
9 27
28#define PANGO_ENABLE_BACKEND
29#define G_DISABLE_CAST_CHECKS
30
31#include <glib/gmacros.h>
32
10#include <pango/pango.h> 33#include <pango/pango.h>
11#include <pango/pangofc-fontmap.h>
12#include <pango/pangoft2.h>
13 34
35#ifndef _WIN32
14#include <sys/types.h> 36# include <sys/types.h>
15#include <sys/socket.h> 37# include <sys/socket.h>
16#include <netinet/in.h> 38# include <netinet/in.h>
17#include <netinet/tcp.h> 39# include <netinet/tcp.h>
40# include <inttypes.h>
41#else
42 typedef unsigned char uint8_t;
43 typedef unsigned short uint16_t;
44 typedef unsigned int uint32_t;
45 typedef signed char int8_t;
46 typedef signed short int16_t;
47 typedef signed int int32_t;
48#endif
18 49
50#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, objetc replacement character */
51
52#define FOW_DARKNESS 32
53
54#define MAP_EXTEND_X 32
55#define MAP_EXTEND_Y 512
56
57#define MIN_FONT_HEIGHT 10
58
59#if 0
60# define PARACHUTE SDL_INIT_NOPARACHUTE
61#else
62# define PARACHUTE 0
63#endif
64
65static struct
66{
67#define GL_FUNC(ptr,name) ptr name;
68#include "glfunc.h"
69#undef GL_FUNC
70} gl;
71
72static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
73{
74 if (gl.BlendFuncSeparate)
75 gl.BlendFuncSeparate (sa, da, saa, daa);
76 else if (gl.BlendFuncSeparateEXT)
77 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
78 else
79 glBlendFunc (sa, da);
80}
81
82#include "texcache.c"
83
84#include "pango-font.c"
85#include "pango-fontmap.c"
86#include "pango-render.c"
87
88typedef Mix_Chunk *CFPlus__MixChunk;
89typedef Mix_Music *CFPlus__MixMusic;
90
91typedef PangoFontDescription *CFPlus__Font;
92
93static int
94shape_attr_p (PangoLayoutRun *run)
95{
96 GSList *attrs = run->item->analysis.extra_attrs;
97
98 while (attrs)
99 {
100 PangoAttribute *attr = attrs->data;
101
102 if (attr->klass->type == PANGO_ATTR_SHAPE)
103 return 1;
104
105 attrs = attrs->next;
106 }
107
108 return 0;
109}
110
111typedef struct cf_layout {
112 PangoLayout *pl;
113 float r, g, b, a; // default color for rgba mode
114 int base_height;
115 CFPlus__Font font;
116} *CFPlus__Layout;
117
118static CFPlus__Font default_font;
19static PangoContext *context; 119static PangoContext *opengl_context;
20static PangoFontMap *fontmap; 120static PangoFontMap *opengl_fontmap;
21 121
22MODULE = Crossfire::Client PACKAGE = Crossfire::Client 122static void
123substitute_func (FcPattern *pattern, gpointer data)
124{
125 FcPatternAddBool (pattern, FC_HINTING, 1);
126#ifdef FC_HINT_STYLE
127 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);
128#endif
129 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
130}
131
132static void
133layout_update_font (CFPlus__Layout self)
134{
135 /* use a random scale factor to account for unknown descenders, 0.8 works
136 * reasonably well with bitstream vera
137 */
138 PangoFontDescription *font = self->font ? self->font : default_font;
139
140 pango_font_description_set_absolute_size (font,
141 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
142
143 pango_layout_set_font_description (self->pl, font);
144}
145
146static void
147layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
148{
149 PangoRectangle rect;
150
151 // get_pixel_* wrongly rounds down
152 pango_layout_get_extents (self->pl, 0, &rect);
153
154 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
155 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
156
157 if (!rect.width) rect.width = 1;
158 if (!rect.height) rect.height = 1;
159
160 *w = rect.width;
161 *h = rect.height;
162}
163
164typedef uint16_t mapface;
165
166typedef struct {
167 GLint name;
168 int w, h;
169 float s, t;
170 uint8_t r, g, b, a;
171} maptex;
172
173typedef struct {
174 int16_t darkness;
175 mapface face[3];
176} mapcell;
177
178typedef struct {
179 int32_t c0, c1;
180 mapcell *col;
181} maprow;
182
183typedef struct map {
184 int x, y, w, h;
185 int ox, oy; /* offset to virtual global coordinate system */
186 int faces;
187 mapface *face;
188
189 int texs;
190 maptex *tex;
191
192 int32_t rows;
193 maprow *row;
194} *CFPlus__Map;
195
196static char *
197prepend (char *ptr, int sze, int inc)
198{
199 char *p;
200
201 New (0, p, sze + inc, char);
202 Zero (p, inc, char);
203 Move (ptr, p + inc, sze, char);
204 Safefree (ptr);
205
206 return p;
207}
208
209static char *
210append (char *ptr, int sze, int inc)
211{
212 Renew (ptr, sze + inc, char);
213 Zero (ptr + sze, inc, char);
214
215 return ptr;
216}
217
218#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
219#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
220
221static maprow *
222map_get_row (CFPlus__Map self, int y)
223{
224 if (0 > y)
225 {
226 int extend = - y + MAP_EXTEND_Y;
227 Prepend (maprow, self->row, self->rows, extend);
228
229 self->rows += extend;
230 self->y += extend;
231 y += extend;
232 }
233 else if (y >= self->rows)
234 {
235 int extend = y - self->rows + MAP_EXTEND_Y;
236 Append (maprow, self->row, self->rows, extend);
237 self->rows += extend;
238 }
239
240 return self->row + y;
241}
242
243static mapcell *
244row_get_cell (maprow *row, int x)
245{
246 if (!row->col)
247 {
248 Newz (0, row->col, MAP_EXTEND_X, mapcell);
249 row->c0 = x - MAP_EXTEND_X / 4;
250 row->c1 = row->c0 + MAP_EXTEND_X;
251 }
252
253 if (row->c0 > x)
254 {
255 int extend = row->c0 - x + MAP_EXTEND_X;
256 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
257 row->c0 -= extend;
258 }
259 else if (x >= row->c1)
260 {
261 int extend = x - row->c1 + MAP_EXTEND_X;
262 Append (mapcell, row->col, row->c1 - row->c0, extend);
263 row->c1 += extend;
264 }
265
266 return row->col + (x - row->c0);
267}
268
269static mapcell *
270map_get_cell (CFPlus__Map self, int x, int y)
271{
272 return row_get_cell (map_get_row (self, y), x);
273}
274
275static void
276map_clear (CFPlus__Map self)
277{
278 int r;
279
280 for (r = 0; r < self->rows; r++)
281 Safefree (self->row[r].col);
282
283 Safefree (self->row);
284
285 self->x = 0;
286 self->y = 0;
287 self->ox = 0;
288 self->oy = 0;
289 self->row = 0;
290 self->rows = 0;
291}
292
293static void
294map_blank (CFPlus__Map self, int x0, int y0, int w, int h)
295{
296 int x, y;
297 maprow *row;
298
299 for (y = y0; y < y0 + h; y++)
300 if (y >= 0)
301 {
302 if (y >= self->rows)
303 break;
304
305 row = self->row + y;
306
307 for (x = x0; x < x0 + w; x++)
308 if (x >= row->c0)
309 {
310 if (x >= row->c1)
311 break;
312
313 row->col[x - row->c0].darkness = -1;
314 }
315 }
316}
317
318static void
319music_finished (void)
320{
321 SDL_UserEvent ev;
322
323 ev.type = SDL_USEREVENT;
324 ev.code = 0;
325 ev.data1 = 0;
326 ev.data2 = 0;
327
328 SDL_PushEvent ((SDL_Event *)&ev);
329}
330
331static void
332channel_finished (int channel)
333{
334 SDL_UserEvent ev;
335
336 ev.type = SDL_USEREVENT;
337 ev.code = 1;
338 ev.data1 = (void *)(long)channel;
339 ev.data2 = 0;
340
341 SDL_PushEvent ((SDL_Event *)&ev);
342}
343
344static unsigned int
345minpot (unsigned int n)
346{
347 if (!n)
348 return 0;
349
350 --n;
351
352 n |= n >> 1;
353 n |= n >> 2;
354 n |= n >> 4;
355 n |= n >> 8;
356 n |= n >> 16;
357
358 return n + 1;
359}
360
361MODULE = CFPlus PACKAGE = CFPlus
23 362
24PROTOTYPES: ENABLE 363PROTOTYPES: ENABLE
25 364
26BOOT: 365BOOT:
27{ 366{
28 fontmap = pango_ft2_font_map_new (); 367 HV *stash = gv_stashpv ("CFPlus", 1);
368 static const struct {
369 const char *name;
370 IV iv;
371 } *civ, const_iv[] = {
372# define const_iv(name) { # name, (IV)name }
373 const_iv (SDL_ACTIVEEVENT),
374 const_iv (SDL_KEYDOWN),
375 const_iv (SDL_KEYUP),
376 const_iv (SDL_MOUSEMOTION),
377 const_iv (SDL_MOUSEBUTTONDOWN),
378 const_iv (SDL_MOUSEBUTTONUP),
379 const_iv (SDL_JOYAXISMOTION),
380 const_iv (SDL_JOYBALLMOTION),
381 const_iv (SDL_JOYHATMOTION),
382 const_iv (SDL_JOYBUTTONDOWN),
383 const_iv (SDL_JOYBUTTONUP),
384 const_iv (SDL_QUIT),
385 const_iv (SDL_SYSWMEVENT),
386 const_iv (SDL_EVENT_RESERVEDA),
387 const_iv (SDL_EVENT_RESERVEDB),
388 const_iv (SDL_VIDEORESIZE),
389 const_iv (SDL_VIDEOEXPOSE),
390 const_iv (SDL_USEREVENT),
391 const_iv (SDLK_KP0),
392 const_iv (SDLK_KP1),
393 const_iv (SDLK_KP2),
394 const_iv (SDLK_KP3),
395 const_iv (SDLK_KP4),
396 const_iv (SDLK_KP5),
397 const_iv (SDLK_KP6),
398 const_iv (SDLK_KP7),
399 const_iv (SDLK_KP8),
400 const_iv (SDLK_KP9),
401 const_iv (SDLK_KP_PERIOD),
402 const_iv (SDLK_KP_DIVIDE),
403 const_iv (SDLK_KP_MULTIPLY),
404 const_iv (SDLK_KP_MINUS),
405 const_iv (SDLK_KP_PLUS),
406 const_iv (SDLK_KP_ENTER),
407 const_iv (SDLK_KP_EQUALS),
408 const_iv (SDLK_UP),
409 const_iv (SDLK_DOWN),
410 const_iv (SDLK_RIGHT),
411 const_iv (SDLK_LEFT),
412 const_iv (SDLK_INSERT),
413 const_iv (SDLK_HOME),
414 const_iv (SDLK_END),
415 const_iv (SDLK_PAGEUP),
416 const_iv (SDLK_PAGEDOWN),
417 const_iv (SDLK_F1),
418 const_iv (SDLK_F2),
419 const_iv (SDLK_F3),
420 const_iv (SDLK_F4),
421 const_iv (SDLK_F5),
422 const_iv (SDLK_F6),
423 const_iv (SDLK_F7),
424 const_iv (SDLK_F8),
425 const_iv (SDLK_F9),
426 const_iv (SDLK_F10),
427 const_iv (SDLK_F11),
428 const_iv (SDLK_F12),
429 const_iv (SDLK_F13),
430 const_iv (SDLK_F14),
431 const_iv (SDLK_F15),
432 const_iv (SDLK_NUMLOCK),
433 const_iv (SDLK_CAPSLOCK),
434 const_iv (SDLK_SCROLLOCK),
435 const_iv (SDLK_RSHIFT),
436 const_iv (SDLK_LSHIFT),
437 const_iv (SDLK_RCTRL),
438 const_iv (SDLK_LCTRL),
439 const_iv (SDLK_RALT),
440 const_iv (SDLK_LALT),
441 const_iv (SDLK_RMETA),
442 const_iv (SDLK_LMETA),
443 const_iv (SDLK_LSUPER),
444 const_iv (SDLK_RSUPER),
445 const_iv (SDLK_MODE),
446 const_iv (SDLK_COMPOSE),
447 const_iv (SDLK_HELP),
448 const_iv (SDLK_PRINT),
449 const_iv (SDLK_SYSREQ),
450 const_iv (SDLK_BREAK),
451 const_iv (SDLK_MENU),
452 const_iv (SDLK_POWER),
453 const_iv (SDLK_EURO),
454 const_iv (SDLK_UNDO),
455 const_iv (KMOD_NONE),
456 const_iv (KMOD_LSHIFT),
457 const_iv (KMOD_RSHIFT),
458 const_iv (KMOD_LCTRL),
459 const_iv (KMOD_RCTRL),
460 const_iv (KMOD_LALT),
461 const_iv (KMOD_RALT),
462 const_iv (KMOD_LMETA),
463 const_iv (KMOD_RMETA),
464 const_iv (KMOD_NUM),
465 const_iv (KMOD_CAPS),
466 const_iv (KMOD_MODE),
467 const_iv (KMOD_CTRL),
468 const_iv (KMOD_SHIFT),
469 const_iv (KMOD_ALT),
470 const_iv (KMOD_META)
471# undef const_iv
472 };
473
474 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
475 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
476}
477
478int
479in_destruct ()
480 CODE:
481 RETVAL = PL_main_cv == Nullcv;
482 OUTPUT:
483 RETVAL
484
485NV floor (NV x)
486
487NV ceil (NV x)
488
489void
490pango_init ()
491 CODE:
492{
493 opengl_fontmap = pango_opengl_font_map_new ();
494 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
29 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap); 495 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
30} 496}
497
498int
499SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
500
501void
502SDL_Quit ()
503
504void
505SDL_ListModes ()
506 PPCODE:
507{
508 SDL_Rect **m;
509
510 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
511 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
512 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
513 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1);
514
515 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
516 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0);
517
518 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0);
519 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
520 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0);
521 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
522
523 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
524#if SDL_VERSION_ATLEAST(1,2,10)
525 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
526 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
527#endif
528
529 SDL_EnableUNICODE (1);
530 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
531
532 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
533
534 if (m && m != (SDL_Rect **)-1)
535 while (*m)
536 {
537 AV *av = newAV ();
538 av_push (av, newSViv ((*m)->w));
539 av_push (av, newSViv ((*m)->h));
540 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
541
542 ++m;
543 }
544}
545
546char *
547SDL_GetError ()
548
549int
550SDL_SetVideoMode (int w, int h, int fullscreen)
551 CODE:
552 RETVAL = !!SDL_SetVideoMode (
553 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
554 );
555 if (RETVAL)
556 {
557 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
558# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
559# include "glfunc.h"
560# undef GL_FUNC
561 }
562 OUTPUT:
563 RETVAL
564
565void
566SDL_GL_SwapBuffers ()
567
568char *
569SDL_GetKeyName (int sym)
570
571void
572SDL_PollEvent ()
573 PPCODE:
574{
575 SDL_Event ev;
576
577 while (SDL_PollEvent (&ev))
578 {
579 HV *hv = newHV ();
580 hv_store (hv, "type", 4, newSViv (ev.type), 0);
581
582 switch (ev.type)
583 {
584 case SDL_KEYDOWN:
585 case SDL_KEYUP:
586 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
587 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
588 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
589 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
590 break;
591
592 case SDL_ACTIVEEVENT:
593 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
594 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
595 break;
596
597 case SDL_MOUSEMOTION:
598 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
599
600 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0);
601 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0);
602 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0);
603 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0);
604 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0);
605 break;
606
607 case SDL_MOUSEBUTTONDOWN:
608 case SDL_MOUSEBUTTONUP:
609 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
610
611 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
612 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
613 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
614 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
615 break;
616
617 case SDL_USEREVENT:
618 hv_store (hv, "code", 4, newSViv (ev.user.code), 0);
619 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
620 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
621 break;
622 }
623
624 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));
625 }
626}
627
628int
629Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048)
630 POSTCALL:
631 Mix_HookMusicFinished (music_finished);
632 Mix_ChannelFinished (channel_finished);
633
634void
635Mix_CloseAudio ()
636
637int
638Mix_AllocateChannels (int numchans = -1)
31 639
32void 640void
33lowdelay (int fd, int val = 1) 641lowdelay (int fd, int val = 1)
34 CODE: 642 CODE:
643#ifndef _WIN32
35 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 644 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
645#endif
646
647void
648add_font (char *file)
649 CODE:
650 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
651
652void
653load_image_inline (SV *image_)
654 ALIAS:
655 load_image_file = 1
656 PPCODE:
657{
658 STRLEN image_len;
659 char *image = (char *)SvPVbyte (image_, image_len);
660 SDL_Surface *surface, *surface2;
661 SDL_PixelFormat fmt;
662 SDL_RWops *rw = ix
663 ? SDL_RWFromFile (image, "r")
664 : SDL_RWFromConstMem (image, image_len);
665
666 if (!rw)
667 croak ("load_image: %s", SDL_GetError ());
668
669 surface = IMG_Load_RW (rw, 1);
670 if (!surface)
671 croak ("load_image: %s", SDL_GetError ());
672
673 fmt.palette = NULL;
674 fmt.BitsPerPixel = 32;
675 fmt.BytesPerPixel = 4;
676#if SDL_BYTEORDER == SDL_LIL_ENDIAN
677 fmt.Rmask = 0x000000ff;
678 fmt.Gmask = 0x0000ff00;
679 fmt.Bmask = 0x00ff0000;
680 fmt.Amask = 0xff000000;
681#else
682 fmt.Rmask = 0xff000000;
683 fmt.Gmask = 0x00ff0000;
684 fmt.Bmask = 0x0000ff00;
685 fmt.Amask = 0x000000ff;
686#endif
687 fmt.Rloss = 0;
688 fmt.Gloss = 0;
689 fmt.Bloss = 0;
690 fmt.Aloss = 0;
691 fmt.Rshift = 0;
692 fmt.Gshift = 8;
693 fmt.Bshift = 16;
694 fmt.Ashift = 24;
695 fmt.colorkey = 0;
696 fmt.alpha = 0;
697
698 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
699
700 assert (surface2->pitch == surface2->w * 4);
701
702 SDL_LockSurface (surface2);
703 EXTEND (SP, 6);
704 PUSHs (sv_2mortal (newSViv (surface2->w)));
705 PUSHs (sv_2mortal (newSViv (surface2->h)));
706 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
707 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
708 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
709 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
710 SDL_UnlockSurface (surface2);
711
712 SDL_FreeSurface (surface);
713 SDL_FreeSurface (surface2);
714}
715
716void
717average (int x, int y, uint32_t *data)
718 PPCODE:
719{
720 uint32_t r = 0, g = 0, b = 0, a = 0;
721
722 x = y = x * y;
723
724 while (x--)
725 {
726 uint32_t p = *data++;
727
728 r += (p ) & 255;
729 g += (p >> 8) & 255;
730 b += (p >> 16) & 255;
731 a += (p >> 24) & 255;
732 }
733
734 EXTEND (SP, 4);
735 PUSHs (sv_2mortal (newSViv (r / y)));
736 PUSHs (sv_2mortal (newSViv (g / y)));
737 PUSHs (sv_2mortal (newSViv (b / y)));
738 PUSHs (sv_2mortal (newSViv (a / y)));
739}
740
741void
742error (char *message)
743 CODE:
744 fprintf (stderr, "ERROR: %s\n", message);
745#ifdef _WIN32
746 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR);
747#endif
748
749void
750fatal (char *message)
751 CODE:
752 fprintf (stderr, "FATAL: %s\n", message);
753#ifdef _WIN32
754 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
755#endif
756 _exit (1);
757
758void
759_exit (int retval)
760 CODE:
761 _exit (retval);
762
763MODULE = CFPlus PACKAGE = CFPlus::Font
764
765CFPlus::Font
766new_from_file (SV *class, char *path, int id = 0)
767 CODE:
768{
769 int count;
770 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
771 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
772 FcPatternDestroy (pattern);
773}
774 OUTPUT:
775 RETVAL
776
777void
778DESTROY (CFPlus::Font self)
779 CODE:
780 pango_font_description_free (self);
781
782void
783make_default (CFPlus::Font self)
784 CODE:
785 default_font = self;
786
787MODULE = CFPlus PACKAGE = CFPlus::Layout
788
789void
790reset_glyph_cache ()
791 CODE:
792 tc_clear ();
793
794CFPlus::Layout
795new (SV *class)
796 CODE:
797 New (0, RETVAL, 1, struct cf_layout);
798
799 RETVAL->pl = pango_layout_new (opengl_context);
800 RETVAL->r = 1.;
801 RETVAL->g = 1.;
802 RETVAL->b = 1.;
803 RETVAL->a = 1.;
804 RETVAL->base_height = MIN_FONT_HEIGHT;
805 RETVAL->font = 0;
806
807 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
808 layout_update_font (RETVAL);
809 OUTPUT:
810 RETVAL
811
812void
813DESTROY (CFPlus::Layout self)
814 CODE:
815 g_object_unref (self->pl);
816 Safefree (self);
817
818void
819set_text (CFPlus::Layout self, SV *text_)
820 CODE:
821{
822 STRLEN textlen;
823 char *text = SvPVutf8 (text_, textlen);
824
825 pango_layout_set_text (self->pl, text, textlen);
826}
827
828void
829set_markup (CFPlus::Layout self, SV *text_)
830 CODE:
831{
832 STRLEN textlen;
833 char *text = SvPVutf8 (text_, textlen);
834
835 pango_layout_set_markup (self->pl, text, textlen);
836}
837
838void
839set_shapes (CFPlus::Layout self, ...)
840 CODE:
841{
842 PangoAttrList *attrs = 0;
843 const char *text = pango_layout_get_text (self->pl);
844 const char *pos = text;
845 int arg = 4;
846
847 while (arg < items && (pos = strstr (pos, OBJ_STR)))
848 {
849 PangoRectangle inkrect, rect;
850 PangoAttribute *attr;
851
852 int x = SvIV (ST (arg - 3));
853 int y = SvIV (ST (arg - 2));
854 int w = SvIV (ST (arg - 1));
855 int h = SvIV (ST (arg ));
856
857 inkrect.x = 0;
858 inkrect.y = 0;
859 inkrect.width = 0;
860 inkrect.height = 0;
861
862 rect.x = x * PANGO_SCALE;
863 rect.y = y * PANGO_SCALE;
864 rect.width = w * PANGO_SCALE;
865 rect.height = h * PANGO_SCALE;
866
867 if (!attrs)
868 attrs = pango_layout_get_attributes (self->pl);
869
870 attr = pango_attr_shape_new (&inkrect, &rect);
871 attr->start_index = pos - text;
872 attr->end_index = attr->start_index + sizeof (OBJ_STR) - 1;
873 pango_attr_list_insert (attrs, attr);
874
875 arg += 4;
876 pos += sizeof (OBJ_STR) - 1;
877 }
878
879 if (attrs)
880 pango_layout_set_attributes (self->pl, attrs);
881}
882
883void
884get_shapes (CFPlus::Layout self)
885 PPCODE:
886{
887 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
888
889 do
890 {
891 PangoLayoutRun *run = pango_layout_iter_get_run (iter);
892
893 if (run && shape_attr_p (run))
894 {
895 PangoRectangle extents;
896 pango_layout_iter_get_run_extents (iter, 0, &extents);
897
898 EXTEND (SP, 2);
899 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.x))));
900 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.y))));
901 }
902 }
903 while (pango_layout_iter_next_run (iter));
904
905 pango_layout_iter_free (iter);
906}
907
908int
909has_wrapped (CFPlus::Layout self)
910 CODE:
911{
912 int lines = 1;
913 const char *text = pango_layout_get_text (self->pl);
914
915 while (*text)
916 lines += *text++ == '\n';
917
918 RETVAL = lines < pango_layout_get_line_count (self->pl);
919}
920 OUTPUT:
921 RETVAL
922
923SV *
924get_text (CFPlus::Layout self)
925 CODE:
926 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
927 sv_utf8_decode (RETVAL);
928 OUTPUT:
929 RETVAL
930
931void
932set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)
933 CODE:
934 self->r = r;
935 self->g = g;
936 self->b = b;
937 self->a = a;
938
939void
940set_font (CFPlus::Layout self, CFPlus::Font font = 0)
941 CODE:
942 if (self->font != font)
943 {
944 self->font = font;
945 layout_update_font (self);
946 }
947
948void
949set_height (CFPlus::Layout self, int base_height)
950 CODE:
951 if (self->base_height != base_height)
952 {
953 self->base_height = base_height;
954 layout_update_font (self);
955 }
956
957void
958set_width (CFPlus::Layout self, int max_width = -1)
959 CODE:
960 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
961
962void
963set_indent (CFPlus::Layout self, int indent)
964 CODE:
965 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
966
967void
968set_spacing (CFPlus::Layout self, int spacing)
969 CODE:
970 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
971
972void
973set_ellipsise (CFPlus::Layout self, int ellipsise)
974 CODE:
975 pango_layout_set_ellipsize (self->pl,
976 ellipsise == 1 ? PANGO_ELLIPSIZE_START
977 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
978 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
979 : PANGO_ELLIPSIZE_NONE
980 );
981
982void
983set_single_paragraph_mode (CFPlus::Layout self, int spm)
984 CODE:
985 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
986
987void
988size (CFPlus::Layout self)
989 PPCODE:
990{
991 int w, h;
992
993 layout_get_pixel_size (self, &w, &h);
994
995 EXTEND (SP, 2);
996 PUSHs (sv_2mortal (newSViv (w)));
997 PUSHs (sv_2mortal (newSViv (h)));
998}
999
1000int
1001descent (CFPlus::Layout self)
1002 CODE:
1003{
1004 PangoRectangle rect;
1005 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
1006 pango_layout_line_get_pixel_extents (line, 0, &rect);
1007 RETVAL = PANGO_DESCENT (rect);
1008}
1009 OUTPUT:
1010 RETVAL
1011
1012int
1013xy_to_index (CFPlus::Layout self, int x, int y)
1014 CODE:
1015{
1016 int index, trailing;
1017 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1018 RETVAL = index;
1019}
1020 OUTPUT:
1021 RETVAL
1022
1023void
1024cursor_pos (CFPlus::Layout self, int index)
1025 PPCODE:
1026{
1027 PangoRectangle strong_pos;
1028 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
1029
1030 EXTEND (SP, 3);
1031 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
1032 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
1033 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
1034}
1035
1036void
1037render (CFPlus::Layout self, float x, float y, int flags = 0)
1038 PPCODE:
1039 pango_opengl_render_layout_subpixel (
1040 self->pl,
1041 x * PANGO_SCALE, y * PANGO_SCALE,
1042 self->r, self->g, self->b, self->a,
1043 flags
1044 );
1045
1046MODULE = CFPlus PACKAGE = CFPlus::Texture
1047
1048void
1049pad2pot (SV *data_, SV *w_, SV *h_)
1050 CODE:
1051{
1052 int ow = SvIV (w_);
1053 int oh = SvIV (h_);
1054
1055 if (ow && oh)
1056 {
1057 int nw = minpot (ow);
1058 int nh = minpot (oh);
1059
1060 if (nw != ow || nh != oh)
1061 {
1062 if (SvOK (data_))
1063 {
1064 STRLEN datalen;
1065 char *data = SvPVbyte (data_, datalen);
1066 int bpp = datalen / (ow * oh);
1067 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1068
1069 SvPOK_only (result_);
1070 SvCUR_set (result_, nw * nh * bpp);
1071
1072 memset (SvPVX (result_), 0, nw * nh * bpp);
1073 while (oh--)
1074 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1075
1076 sv_setsv (data_, result_);
1077 }
1078
1079 sv_setiv (w_, nw);
1080 sv_setiv (h_, nh);
1081 }
1082 }
1083}
1084
1085void
1086draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
1087 PROTOTYPE: $$$;$$
1088 ALIAS:
1089 draw_quad_alpha = 1
1090 draw_quad_alpha_premultiplied = 2
1091 CODE:
1092{
1093 HV *hv = (HV *)SvRV (self);
1094 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
1095 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
1096 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
1097
1098 if (items < 5)
1099 {
1100 w = SvNV (*hv_fetch (hv, "w", 1, 1));
1101 h = SvNV (*hv_fetch (hv, "h", 1, 1));
1102 }
1103
1104 if (ix)
1105 {
1106 glEnable (GL_BLEND);
1107
1108 if (ix == 2)
1109 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1110 else
1111 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1112 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1113
1114 glEnable (GL_ALPHA_TEST);
1115 glAlphaFunc (GL_GREATER, 0.01f);
1116 }
1117
1118 glBindTexture (GL_TEXTURE_2D, name);
1119
1120 glBegin (GL_QUADS);
1121 glTexCoord2f (0, 0); glVertex2f (x , y );
1122 glTexCoord2f (0, t); glVertex2f (x , y + h);
1123 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
1124 glTexCoord2f (s, 0); glVertex2f (x + w, y );
1125 glEnd ();
1126
1127 if (ix)
1128 {
1129 glDisable (GL_ALPHA_TEST);
1130 glDisable (GL_BLEND);
1131 }
1132}
1133
1134MODULE = CFPlus PACKAGE = CFPlus::Map
1135
1136CFPlus::Map
1137new (SV *class, int map_width, int map_height)
1138 CODE:
1139 New (0, RETVAL, 1, struct map);
1140 RETVAL->x = 0;
1141 RETVAL->y = 0;
1142 RETVAL->w = map_width;
1143 RETVAL->h = map_height;
1144 RETVAL->ox = 0;
1145 RETVAL->oy = 0;
1146 RETVAL->faces = 8192;
1147 Newz (0, RETVAL->face, RETVAL->faces, mapface);
1148 RETVAL->texs = 8192;
1149 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
1150 RETVAL->rows = 0;
1151 RETVAL->row = 0;
1152 OUTPUT:
1153 RETVAL
1154
1155void
1156DESTROY (CFPlus::Map self)
1157 CODE:
1158{
1159 map_clear (self);
1160 Safefree (self->face);
1161 Safefree (self->tex);
1162 Safefree (self);
1163}
1164
1165void
1166clear (CFPlus::Map self)
1167 CODE:
1168 map_clear (self);
1169
1170void
1171set_face (CFPlus::Map self, int face, int texid)
1172 CODE:
1173{
1174 while (self->faces <= face)
1175 {
1176 Append (mapface, self->face, self->faces, self->faces);
1177 self->faces *= 2;
1178 }
1179
1180 self->face [face] = texid;
1181}
1182
1183void
1184set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1185 CODE:
1186{
1187 while (self->texs <= texid)
1188 {
1189 Append (maptex, self->tex, self->texs, self->texs);
1190 self->texs *= 2;
1191 }
1192
1193 {
1194 maptex *tex = self->tex + texid;
1195
1196 tex->name = name;
1197 tex->w = w;
1198 tex->h = h;
1199 tex->s = s;
1200 tex->t = t;
1201 tex->r = r;
1202 tex->g = g;
1203 tex->b = b;
1204 tex->a = a;
1205 }
1206
1207 // somewhat hackish, but for textures that require it, it really
1208 // improves the look, and most others don't suffer.
1209 glBindTexture (GL_TEXTURE_2D, name);
1210 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1211 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1212 // use uglier nearest interpolation because linear suffers
1213 // from transparent color bleeding and ugly wrapping effects.
1214 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1215}
1216
1217int
1218ox (CFPlus::Map self)
1219 ALIAS:
1220 oy = 1
1221 x = 2
1222 y = 3
1223 w = 4
1224 h = 5
1225 CODE:
1226 switch (ix)
1227 {
1228 case 0: RETVAL = self->ox; break;
1229 case 1: RETVAL = self->oy; break;
1230 case 2: RETVAL = self->x; break;
1231 case 3: RETVAL = self->y; break;
1232 case 4: RETVAL = self->w; break;
1233 case 5: RETVAL = self->h; break;
1234 }
1235 OUTPUT:
1236 RETVAL
1237
1238void
1239scroll (CFPlus::Map self, int dx, int dy)
1240 CODE:
1241{
1242 if (dx > 0)
1243 map_blank (self, self->x, self->y, dx - 1, self->h);
1244 else if (dx < 0)
1245 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h);
1246
1247 if (dy > 0)
1248 map_blank (self, self->x, self->y, self->w, dy - 1);
1249 else if (dy < 0)
1250 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy);
1251
1252 self->ox += dx; self->x += dx;
1253 self->oy += dy; self->y += dy;
1254
1255 while (self->y < 0)
1256 {
1257 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
1258
1259 self->rows += MAP_EXTEND_Y;
1260 self->y += MAP_EXTEND_Y;
1261 }
1262}
1263
1264void
1265map1a_update (CFPlus::Map self, SV *data_)
1266 CODE:
1267{
1268 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1269 uint8_t *data_end = (uint8_t *)SvEND (data_);
1270 mapcell *cell;
1271 int x, y, flags;
1272
1273 while (data < data_end)
1274 {
1275 flags = (data [0] << 8) + data [1]; data += 2;
1276
1277 x = self->x + ((flags >> 10) & 63);
1278 y = self->y + ((flags >> 4) & 63);
1279
1280 cell = map_get_cell (self, x, y);
1281
1282 if (flags & 15)
1283 {
1284 if (cell->darkness < 0)
1285 {
1286 cell->darkness = 0;
1287 cell->face [0] = 0;
1288 cell->face [1] = 0;
1289 cell->face [2] = 0;
1290 }
1291
1292 cell->darkness = flags & 8 ? *data++ : 255;
1293
1294 //TODO: don't trust server data to be in-range(!)
1295
1296 if (flags & 4)
1297 {
1298 cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2;
1299 }
1300
1301 if (flags & 2)
1302 {
1303 cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2;
1304 }
1305
1306 if (flags & 1)
1307 {
1308 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
1309 }
1310 }
1311 else
1312 cell->darkness = -1;
1313 }
1314}
1315
1316SV *
1317mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
1318 CODE:
1319{
1320 int x1, x;
1321 int y1, y;
1322 int z;
1323 SV *map_sv = newSV (w * h * sizeof (uint32_t));
1324 uint32_t *map = (uint32_t *)SvPVX (map_sv);
1325
1326 SvPOK_only (map_sv);
1327 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
1328
1329 x0 += self->x; x1 = x0 + w;
1330 y0 += self->y; y1 = y0 + h;
1331
1332 for (y = y0; y < y1; y++)
1333 {
1334 maprow *row = 0 <= y && y < self->rows
1335 ? self->row + y
1336 : 0;
1337
1338 for (x = x0; x < x1; x++)
1339 {
1340 int r = 32, g = 32, b = 32, a = 192;
1341
1342 if (row && row->c0 <= x && x < row->c1)
1343 {
1344 mapcell *cell = row->col + (x - row->c0);
1345
1346 for (z = 0; z <= 0; z++)
1347 {
1348 mapface face = cell->face [z];
1349
1350 if (face)
1351 {
1352 maptex tex = self->tex [face];
1353 int a0 = 255 - tex.a;
1354 int a1 = tex.a;
1355
1356 r = (r * a0 + tex.r * a1) / 255;
1357 g = (g * a0 + tex.g * a1) / 255;
1358 b = (b * a0 + tex.b * a1) / 255;
1359 a = (a * a0 + tex.a * a1) / 255;
1360 }
1361 }
1362 }
1363
1364 *map++ = (r )
1365 | (g << 8)
1366 | (b << 16)
1367 | (a << 24);
1368 }
1369 }
1370
1371 RETVAL = map_sv;
1372}
1373 OUTPUT:
1374 RETVAL
1375
1376void
1377draw (CFPlus::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh)
1378 CODE:
1379{
1380 int vx, vy;
1381 int x, y, z;
1382 int last_name;
1383 mapface face;
1384
1385 vx = self->x + self->w / 2 - sw / 2 - shift_x;
1386 vy = self->y + self->h / 2 - sh / 2 - shift_y;
1387
1388 /*
1389 int vx = self->vx = self->w >= sw
1390 ? self->x + (self->w - sw) / 2
1391 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
1392
1393 int vy = self->vy = self->h >= sh
1394 ? self->y + (self->h - sh) / 2
1395 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
1396 */
1397
1398 glColor4ub (255, 255, 255, 255);
1399
1400 glEnable (GL_BLEND);
1401 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1402 glEnable (GL_TEXTURE_2D);
1403 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1404
1405 glBegin (GL_QUADS);
1406
1407 last_name = 0;
1408
1409 for (z = 0; z < 3; z++)
1410 for (y = 0; y < sh; y++)
1411 if (0 <= y + vy && y + vy < self->rows)
1412 {
1413 maprow *row = self->row + (y + vy);
1414
1415 for (x = 0; x < sw; x++)
1416 if (row->c0 <= x + vx && x + vx < row->c1)
1417 {
1418 mapcell *cell = row->col + (x + vx - row->c0);
1419
1420 face = cell->face [z];
1421
1422 if (face)
1423 {
1424 maptex tex = self->tex [face];
1425
1426 int px = (x + 1) * 32 - tex.w;
1427 int py = (y + 1) * 32 - tex.h;
1428
1429 if (last_name != tex.name)
1430 {
1431 glEnd ();
1432 last_name = tex.name;
1433 glBindTexture (GL_TEXTURE_2D, last_name);
1434 glBegin (GL_QUADS);
1435 }
1436
1437 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1438 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1439 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1440 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1441 }
1442 }
1443 }
1444
1445 glEnd ();
1446
1447 glDisable (GL_TEXTURE_2D);
1448 glDisable (GL_BLEND);
1449}
1450
1451void
1452draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1453 CODE:
1454{
1455 static float color[16][3] = {
1456 { 0.00F, 0.00F, 0.00F },
1457 { 1.00F, 1.00F, 1.00F },
1458 { 0.00F, 0.00F, 0.55F },
1459 { 1.00F, 0.00F, 0.00F },
1460
1461 { 1.00F, 0.54F, 0.00F },
1462 { 0.11F, 0.56F, 1.00F },
1463 { 0.93F, 0.46F, 0.00F },
1464 { 0.18F, 0.54F, 0.34F },
1465
1466 { 0.56F, 0.73F, 0.56F },
1467 { 0.80F, 0.80F, 0.80F },
1468 { 0.55F, 0.41F, 0.13F },
1469 { 0.99F, 0.77F, 0.26F },
1470
1471 { 0.74F, 0.65F, 0.41F },
1472
1473 { 0.00F, 1.00F, 1.00F },
1474 { 1.00F, 0.00F, 1.00F },
1475 { 1.00F, 1.00F, 0.00F },
1476 };
1477
1478 int x, y;
1479
1480 glEnable (GL_TEXTURE_2D);
1481 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1482 glEnable (GL_BLEND);
1483 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1484 glBegin (GL_QUADS);
1485
1486 for (y = 0; y < h; y++)
1487 for (x = 0; x < w; x++)
1488 {
1489 unsigned char m = data [x + y * w];
1490
1491 if (m)
1492 {
1493 float *c = color [m & 15];
1494
1495 float tx1 = m & 0x40 ? 0.5 : 0.;
1496 float tx2 = tx1 + 0.5;
1497
1498 glColor4f (c[0], c[1], c[2], 0.75);
1499 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
1500 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
1501 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
1502 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
1503 }
1504 }
1505
1506 glEnd ();
1507 glDisable (GL_BLEND);
1508 glDisable (GL_TEXTURE_2D);
1509}
1510
1511void
1512fow_texture (CFPlus::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh)
1513 PPCODE:
1514{
1515 int vx, vy;
1516 int x, y;
1517 int sw4 = (sw + 3) & ~3;
1518 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));
1519 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv);
1520
1521 memset (darkness, 255, sw4 * sh);
1522 SvPOK_only (darkness_sv);
1523 SvCUR_set (darkness_sv, sw4 * sh);
1524
1525 vx = self->x + (self->w - sw + 1) / 2 - shift_x;
1526 vy = self->y + (self->h - sh + 1) / 2 - shift_y;
1527
1528 for (y = 0; y < sh; y++)
1529 if (0 <= y + vy && y + vy < self->rows)
1530 {
1531 maprow *row = self->row + (y + vy);
1532
1533 for (x = 0; x < sw; x++)
1534 if (row->c0 <= x + vx && x + vx < row->c1)
1535 {
1536 mapcell *cell = row->col + (x + vx - row->c0);
1537
1538 darkness[y * sw4 + x] = cell->darkness < 0
1539 ? 255 - FOW_DARKNESS
1540 : 255 - cell->darkness;
1541 }
1542 }
1543
1544 EXTEND (SP, 3);
1545 PUSHs (sv_2mortal (newSViv (sw4)));
1546 PUSHs (sv_2mortal (newSViv (sh)));
1547 PUSHs (darkness_sv);
1548}
1549
1550SV *
1551get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
1552 CODE:
1553{
1554 int x, y, x1, y1;
1555 SV *data_sv = newSV (w * h * 7 + 5);
1556 uint8_t *data = (uint8_t *)SvPVX (data_sv);
1557
1558 *data++ = 0; /* version 0 format */
1559 *data++ = w >> 8; *data++ = w;
1560 *data++ = h >> 8; *data++ = h;
1561
1562 // we need to do this 'cause we don't keep an absolute coord system for rows
1563 // TODO: treat rows as we treat columns
1564 map_get_row (self, y0 + self->y - self->oy);//D
1565 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
1566
1567 x0 += self->x - self->ox;
1568 y0 += self->y - self->oy;
1569
1570 x1 = x0 + w;
1571 y1 = y0 + h;
1572
1573 for (y = y0; y < y1; y++)
1574 {
1575 maprow *row = 0 <= y && y < self->rows
1576 ? self->row + y
1577 : 0;
1578
1579 for (x = x0; x < x1; x++)
1580 {
1581 if (row && row->c0 <= x && x < row->c1)
1582 {
1583 mapcell *cell = row->col + (x - row->c0);
1584 uint8_t flags = 0;
1585
1586 if (cell->face [0]) flags |= 1;
1587 if (cell->face [1]) flags |= 2;
1588 if (cell->face [2]) flags |= 4;
1589
1590 *data++ = flags;
1591
1592 if (flags & 1)
1593 {
1594 *data++ = cell->face [0] >> 8;
1595 *data++ = cell->face [0];
1596 }
1597
1598 if (flags & 2)
1599 {
1600 *data++ = cell->face [1] >> 8;
1601 *data++ = cell->face [1];
1602 }
1603
1604 if (flags & 4)
1605 {
1606 *data++ = cell->face [2] >> 8;
1607 *data++ = cell->face [2];
1608 }
1609 }
1610 else
1611 *data++ = 0;
1612 }
1613 }
1614
1615 SvPOK_only (data_sv);
1616 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
1617 RETVAL = data_sv;
1618}
1619 OUTPUT:
1620 RETVAL
1621
1622void
1623set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
1624 PPCODE:
1625{
1626 int x, y, z;
1627 int w, h;
1628 int x1, y1;
1629
1630 if (*data++ != 0)
1631 return; /* version mismatch */
1632
1633 w = *data++ << 8; w |= *data++;
1634 h = *data++ << 8; h |= *data++;
1635
1636 // we need to do this 'cause we don't keep an absolute coord system for rows
1637 // TODO: treat rows as we treat columns
1638 map_get_row (self, y0 + self->y - self->oy);//D
1639 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
1640
1641 x0 += self->x - self->ox;
1642 y0 += self->y - self->oy;
1643
1644 x1 = x0 + w;
1645 y1 = y0 + h;
1646
1647 for (y = y0; y < y1; y++)
1648 {
1649 maprow *row = map_get_row (self, y);
1650
1651 for (x = x0; x < x1; x++)
1652 {
1653 uint8_t flags = *data++;
1654
1655 if (flags)
1656 {
1657 mapface face[3] = { 0, 0, 0 };
1658
1659 mapcell *cell = row_get_cell (row, x);
1660
1661 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; }
1662 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; }
1663 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; }
1664
1665 if (cell->darkness <= 0)
1666 {
1667 cell->darkness = -1;
1668
1669 for (z = 0; z <= 2; z++)
1670 {
1671 cell->face[z] = face[z];
1672
1673 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name))
1674 XPUSHs (sv_2mortal (newSViv (face[z])));
1675 }
1676 }
1677 }
1678 }
1679 }
1680}
1681
1682MODULE = CFPlus PACKAGE = CFPlus::MixChunk
1683
1684CFPlus::MixChunk
1685new_from_file (SV *class, char *path)
1686 CODE:
1687 RETVAL = Mix_LoadWAV (path);
1688 OUTPUT:
1689 RETVAL
1690
1691void
1692DESTROY (CFPlus::MixChunk self)
1693 CODE:
1694 Mix_FreeChunk (self);
1695
1696int
1697volume (CFPlus::MixChunk self, int volume = -1)
1698 CODE:
1699 RETVAL = Mix_VolumeChunk (self, volume);
1700 OUTPUT:
1701 RETVAL
1702
1703int
1704play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
1705 CODE:
1706 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
1707 OUTPUT:
1708 RETVAL
1709
1710MODULE = CFPlus PACKAGE = CFPlus::MixMusic
1711
1712int
1713volume (int volume = -1)
1714 CODE:
1715 RETVAL = Mix_VolumeMusic (volume);
1716 OUTPUT:
1717 RETVAL
1718
1719CFPlus::MixMusic
1720new_from_file (SV *class, char *path)
1721 CODE:
1722 RETVAL = Mix_LoadMUS (path);
1723 OUTPUT:
1724 RETVAL
1725
1726void
1727DESTROY (CFPlus::MixMusic self)
1728 CODE:
1729 Mix_FreeMusic (self);
1730
1731int
1732play (CFPlus::MixMusic self, int loops = -1)
1733 CODE:
1734 RETVAL = Mix_PlayMusic (self, loops);
1735 OUTPUT:
1736 RETVAL
1737
1738MODULE = CFPlus PACKAGE = CFPlus::OpenGL
1739
1740BOOT:
1741{
1742 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
1743 static const struct {
1744 const char *name;
1745 IV iv;
1746 } *civ, const_iv[] = {
1747# define const_iv(name) { # name, (IV)name }
1748 const_iv (GL_COLOR_MATERIAL),
1749 const_iv (GL_SMOOTH),
1750 const_iv (GL_FLAT),
1751 const_iv (GL_DITHER),
1752 const_iv (GL_BLEND),
1753 const_iv (GL_CULL_FACE),
1754 const_iv (GL_SCISSOR_TEST),
1755 const_iv (GL_DEPTH_TEST),
1756 const_iv (GL_ALPHA_TEST),
1757 const_iv (GL_NORMALIZE),
1758 const_iv (GL_RESCALE_NORMAL),
1759 const_iv (GL_FRONT),
1760 const_iv (GL_BACK),
1761 const_iv (GL_AND),
1762 const_iv (GL_ONE),
1763 const_iv (GL_ZERO),
1764 const_iv (GL_SRC_ALPHA),
1765 const_iv (GL_DST_ALPHA),
1766 const_iv (GL_ONE_MINUS_SRC_ALPHA),
1767 const_iv (GL_ONE_MINUS_DST_ALPHA),
1768 const_iv (GL_SRC_ALPHA_SATURATE),
1769 const_iv (GL_RGB),
1770 const_iv (GL_RGBA),
1771 const_iv (GL_RGBA4),
1772 const_iv (GL_RGBA8),
1773 const_iv (GL_RGB5_A1),
1774 const_iv (GL_UNSIGNED_BYTE),
1775 const_iv (GL_UNSIGNED_SHORT),
1776 const_iv (GL_UNSIGNED_INT),
1777 const_iv (GL_ALPHA),
1778 const_iv (GL_INTENSITY),
1779 const_iv (GL_LUMINANCE),
1780 const_iv (GL_LUMINANCE_ALPHA),
1781 const_iv (GL_FLOAT),
1782 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
1783 const_iv (GL_COMPILE),
1784 const_iv (GL_TEXTURE_1D),
1785 const_iv (GL_TEXTURE_2D),
1786 const_iv (GL_TEXTURE_ENV),
1787 const_iv (GL_TEXTURE_MAG_FILTER),
1788 const_iv (GL_TEXTURE_MIN_FILTER),
1789 const_iv (GL_TEXTURE_ENV_MODE),
1790 const_iv (GL_TEXTURE_WRAP_S),
1791 const_iv (GL_TEXTURE_WRAP_T),
1792 const_iv (GL_REPEAT),
1793 const_iv (GL_CLAMP),
1794 const_iv (GL_CLAMP_TO_EDGE),
1795 const_iv (GL_NEAREST),
1796 const_iv (GL_LINEAR),
1797 const_iv (GL_NEAREST_MIPMAP_NEAREST),
1798 const_iv (GL_LINEAR_MIPMAP_NEAREST),
1799 const_iv (GL_NEAREST_MIPMAP_LINEAR),
1800 const_iv (GL_LINEAR_MIPMAP_LINEAR),
1801 const_iv (GL_GENERATE_MIPMAP),
1802 const_iv (GL_MODULATE),
1803 const_iv (GL_DECAL),
1804 const_iv (GL_REPLACE),
1805 const_iv (GL_DEPTH_BUFFER_BIT),
1806 const_iv (GL_COLOR_BUFFER_BIT),
1807 const_iv (GL_PROJECTION),
1808 const_iv (GL_MODELVIEW),
1809 const_iv (GL_COLOR_LOGIC_OP),
1810 const_iv (GL_SEPARABLE_2D),
1811 const_iv (GL_CONVOLUTION_2D),
1812 const_iv (GL_CONVOLUTION_BORDER_MODE),
1813 const_iv (GL_CONSTANT_BORDER),
1814 const_iv (GL_LINES),
1815 const_iv (GL_LINE_STRIP),
1816 const_iv (GL_LINE_LOOP),
1817 const_iv (GL_QUADS),
1818 const_iv (GL_QUAD_STRIP),
1819 const_iv (GL_TRIANGLES),
1820 const_iv (GL_TRIANGLE_STRIP),
1821 const_iv (GL_TRIANGLE_FAN),
1822 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
1823 const_iv (GL_FASTEST),
1824 const_iv (GL_V2F),
1825 const_iv (GL_V3F),
1826 const_iv (GL_T2F_V3F),
1827 const_iv (GL_T2F_N3F_V3F),
1828# undef const_iv
1829 };
1830
1831 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1832 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1833}
1834
1835char *
1836gl_vendor ()
1837 CODE:
1838 RETVAL = (char *)glGetString (GL_VENDOR);
1839 OUTPUT:
1840 RETVAL
36 1841
37char * 1842char *
38gl_version () 1843gl_version ()
39 CODE: 1844 CODE:
40 RETVAL = (char *)glGetString (GL_VERSION); 1845 RETVAL = (char *)glGetString (GL_VERSION);
… …
46 CODE: 1851 CODE:
47 RETVAL = (char *)glGetString (GL_EXTENSIONS); 1852 RETVAL = (char *)glGetString (GL_EXTENSIONS);
48 OUTPUT: 1853 OUTPUT:
49 RETVAL 1854 RETVAL
50 1855
51void 1856int glGetError ()
52add_font (char *file)
53 CODE:
54 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */
55 1857
56void 1858void glFinish ()
57set_font (char *file)
58 CODE:
59{
60 int count;
61 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
62 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
63 FcPatternDestroy (pattern);
64 pango_context_set_font_description (context, font);
65}
66 1859
67MODULE = Crossfire::Client PACKAGE = Crossfire::Client 1860void glClear (int mask)
68 1861
69void 1862void glClearColor (float r, float g, float b, float a = 1.0)
70font_render (SV *text_, int height = 10) 1863 PROTOTYPE: @
1864
1865void glEnable (int cap)
1866
1867void glDisable (int cap)
1868
1869void glShadeModel (int mode)
1870
1871void glHint (int target, int mode)
1872
1873void glBlendFunc (int sfactor, int dfactor)
1874
1875void glBlendFuncSeparate (int sa, int da, int saa, int daa)
71 PPCODE: 1876 CODE:
72{ 1877 gl_BlendFuncSeparate (sa, da, saa, daa);
73 STRLEN textlen;
74 char *text = SvPVutf8 (text_, textlen);
75 SV *retval;
76 int w, h;
77 FT_Bitmap bitmap;
78 PangoLayout *layout;
79 PangoFontDescription *font = pango_context_get_font_description (context);
80 pango_font_description_set_absolute_size (font, height * PANGO_SCALE);
81 1878
82 layout = pango_layout_new (context); 1879void glDepthMask (int flag)
83 pango_layout_set_markup (layout, text, textlen);
84 pango_layout_get_pixel_size (layout, &w, &h);
85 1880
86 w = (w + 3) & ~3; 1881void glLogicOp (int opcode)
87 if (!w) w = 1;
88 if (!h) h = 1;
89 1882
90 retval = newSV (w * h); 1883void glColorMask (int red, int green, int blue, int alpha)
91 SvPOK_only (retval);
92 SvCUR_set (retval, w * h);
93 1884
94 bitmap.rows = h; 1885void glMatrixMode (int mode)
95 bitmap.width = w;
96 bitmap.pitch = w;
97 bitmap.buffer = (unsigned char*)SvPVX (retval);
98 bitmap.num_grays = 256;
99 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
100 1886
101 memset (bitmap.buffer, 0, w * h); 1887void glPushMatrix ()
102
103 pango_ft2_render_layout (&bitmap, layout, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
104 g_object_unref (layout);
105 1888
106 EXTEND (SP, 3); 1889void glPopMatrix ()
107 PUSHs (sv_2mortal (newSViv (w)));
108 PUSHs (sv_2mortal (newSViv (h)));
109 PUSHs (sv_2mortal (retval));
110}
111 1890
112MODULE = Crossfire::Client PACKAGE = Crossfire::Client::Texture 1891void glLoadIdentity ()
113 1892
114void 1893void glDrawBuffer (int buffer)
115draw_quad (SV *self, double x, double y, double w = 0, double h = 0) 1894
1895void glReadBuffer (int buffer)
1896
1897# near_ and far_ are due to microsofts buggy "c" compiler
1898void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
1899
1900# near_ and far_ are due to microsofts buggy "c" compiler
1901void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
1902
1903void glViewport (int x, int y, int width, int height)
1904
1905void glScissor (int x, int y, int width, int height)
1906
1907void glTranslate (float x, float y, float z = 0.)
1908 CODE:
1909 glTranslatef (x, y, z);
1910
1911void glScale (float x, float y, float z = 1.)
1912 CODE:
1913 glScalef (x, y, z);
1914
1915void glRotate (float angle, float x, float y, float z)
1916 CODE:
1917 glRotatef (angle, x, y, z);
1918
1919void glBegin (int mode)
1920
1921void glEnd ()
1922
1923void glColor (float r, float g, float b, float a = 1.0)
116 PROTOTYPE: $$$;$$ 1924 PROTOTYPE: @
117 CODE: 1925 ALIAS:
118{ 1926 glColor_premultiply = 1
119 HV *hv = (HV *)SvRV (self); 1927 CODE:
120 double s = SvNV (*hv_fetch (hv, "s", 1, 1));
121 double t = SvNV (*hv_fetch (hv, "t", 1, 1));
122 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
123
124 if (items < 5) 1928 if (ix)
125 { 1929 {
126 w = SvNV (*hv_fetch (hv, "width", 5, 1)); 1930 r *= a;
127 h = SvNV (*hv_fetch (hv, "height", 6, 1)); 1931 g *= a;
1932 b *= a;
128 } 1933 }
1934 // microsoft visual "c" rounds instead of truncating...
1935 glColor4f (r, g, b, a);
129 1936
130 glBindTexture (GL_TEXTURE_2D, name); 1937void glInterleavedArrays (int format, int stride, char *data)
131 glBegin (GL_QUADS); 1938
132 glTexCoord2d (0, 0); glVertex2d (x , y ); 1939void glDrawElements (int mode, int count, int type, char *indices)
133 glTexCoord2d (0, t); glVertex2d (x , y + h); 1940
134 glTexCoord2d (s, t); glVertex2d (x + w, y + h); 1941# 1.2 void glDrawRangeElements (int mode, int start, int end
135 glTexCoord2d (s, 0); glVertex2d (x + w, y ); 1942
136 glEnd (); 1943void glRasterPos (float x, float y, float z = 0.)
1944 CODE:
1945 glRasterPos3f (0, 0, z);
1946 glBitmap (0, 0, 0, 0, x, y, 0);
1947
1948void glVertex (float x, float y, float z = 0.)
1949 CODE:
1950 glVertex3f (x, y, z);
1951
1952void glTexCoord (float s, float t)
1953 CODE:
1954 glTexCoord2f (s, t);
1955
1956void glTexEnv (int target, int pname, float param)
1957 CODE:
1958 glTexEnvf (target, pname, param);
1959
1960void glTexParameter (int target, int pname, float param)
1961 CODE:
1962 glTexParameterf (target, pname, param);
1963
1964void glBindTexture (int target, int name)
1965
1966void glConvolutionParameter (int target, int pname, float params)
1967 CODE:
1968 if (gl.ConvolutionParameterf)
1969 gl.ConvolutionParameterf (target, pname, params);
1970
1971void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
1972 CODE:
1973 if (gl.ConvolutionFilter2D)
1974 gl.ConvolutionFilter2D (target, internalformat, width, height, format, type, data);
1975
1976void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
1977 CODE:
1978 if (gl.SeparableFilter2D)
1979 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
1980
1981void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
1982
1983void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
1984
1985void glDrawPixels (int width, int height, int format, int type, char *pixels)
1986
1987void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
1988
1989int glGenTexture ()
1990 CODE:
1991{
1992 GLuint name;
1993 glGenTextures (1, &name);
1994 RETVAL = name;
137} 1995}
1996 OUTPUT:
1997 RETVAL
1998
1999void glDeleteTexture (int name)
2000 CODE:
2001{
2002 GLuint name_ = name;
2003 glDeleteTextures (1, &name_);
2004}
2005
2006int glGenList ()
2007 CODE:
2008 RETVAL = glGenLists (1);
2009 OUTPUT:
2010 RETVAL
2011
2012void glDeleteList (int list)
2013 CODE:
2014 glDeleteLists (list, 1);
2015
2016void glNewList (int list, int mode = GL_COMPILE)
2017
2018void glEndList ()
2019
2020void glCallList (int list)
2021

Diff Legend

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