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.1 by root, Thu Apr 6 15:30:09 2006 UTC vs.
Revision 1.198 by root, Sun Jul 15 21:42:02 2007 UTC

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

Diff Legend

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