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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines