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.30 by root, Thu Apr 13 23:07:56 2006 UTC vs.
Revision 1.140 by root, Mon Aug 14 03:41:25 2006 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines